mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2025-06-25 01:01:33 +02:00
Code Issues Packages Projects Releases Wiki Activity

refactor: scalar and complex renamed to real_scalar and complex_scalar respectively + concepts refactoring + electromagnetism fixes

Browse Source
This commit is contained in:
Mateusz Pusz
2025-02-11 17:26:19 +01:00
parent 9fb08e3c95
commit 47a82f466c
21 changed files with 569 additions and 579 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
test/runtime/linear_algebra_test.cpp
View File

@ -60,7 +60,8 @@ using namespace mp_units;
using namespace mp_units::si::unit_symbols;
template<QuantitySpec auto QS, QuantityOf<QS> Q>
requires(Q::quantity_spec.character == quantity_character::vector) && (QS.character == quantity_character::scalar)
requires(Q::quantity_spec.character == quantity_character::vector) &&
(QS.character == quantity_character::real_scalar)
[[nodiscard]] constexpr QuantityOf<QS> auto get_magnitude(const Q& q)
{
const auto& v = q.numerical_value_ref_in(q.unit);
@ -68,7 +69,8 @@ template<QuantitySpec auto QS, QuantityOf<QS> Q>
}
template<QuantitySpec auto QS, QuantityOf<QS> T>
requires(T::quantity_spec.character == quantity_character::vector) && (QS.character == quantity_character::scalar)
requires(T::quantity_spec.character == quantity_character::vector) &&
(QS.character == quantity_character::real_scalar)
[[nodiscard]] constexpr QuantityOf<QS> auto get_magnitude(const vector<T>& v)
{
return hypot(QS(v(0)), QS(v(1)), QS(v(2)));

43
test/static/concepts_test.cpp
View File

@ -25,7 +25,6 @@
#include <mp-units/systems/si.h>
#if MP_UNITS_HOSTED
#include <mp-units/cartesian_vector.h>
#include <mp-units/complex.h>
#endif
#ifdef MP_UNITS_IMPORT_STD
import std;
@ -331,30 +330,46 @@ static_assert(!Representation<std::chrono::seconds>);
#endif
// RepresentationOf
static_assert(RepresentationOf<int, quantity_character::scalar>);
static_assert(!RepresentationOf<int, quantity_character::complex>);
static_assert(RepresentationOf<int, quantity_character::real_scalar>);
static_assert(!RepresentationOf<int, quantity_character::complex_scalar>);
static_assert(!RepresentationOf<int, quantity_character::complex_scalar>);
static_assert(RepresentationOf<int, quantity_character::vector>);
static_assert(!RepresentationOf<int, quantity_character::tensor>);
static_assert(RepresentationOf<double, quantity_character::scalar>);
static_assert(!RepresentationOf<double, quantity_character::complex>);
static_assert(RepresentationOf<double, quantity_character::real_scalar>);
static_assert(!RepresentationOf<double, quantity_character::complex_scalar>);
static_assert(!RepresentationOf<double, quantity_character::complex_scalar>);
static_assert(RepresentationOf<double, quantity_character::vector>);
static_assert(!RepresentationOf<double, quantity_character::tensor>);
static_assert(!RepresentationOf<bool, quantity_character::scalar>);
static_assert(!RepresentationOf<bool, quantity_character::complex>);
static_assert(!RepresentationOf<bool, quantity_character::real_scalar>);
static_assert(!RepresentationOf<bool, quantity_character::complex_scalar>);
static_assert(!RepresentationOf<bool, quantity_character::complex_scalar>);
static_assert(!RepresentationOf<bool, quantity_character::vector>);
static_assert(!RepresentationOf<bool, quantity_character::tensor>);
static_assert(!RepresentationOf<std::optional<int>, quantity_character::scalar>);
static_assert(!RepresentationOf<std::optional<int>, quantity_character::real_scalar>);
#if MP_UNITS_HOSTED
static_assert(RepresentationOf<std::complex<double>, quantity_character::complex>);
static_assert(!RepresentationOf<std::complex<double>, quantity_character::scalar>);
static_assert(!RepresentationOf<std::complex<double>, quantity_character::real_scalar>);
static_assert(RepresentationOf<std::complex<double>, quantity_character::complex_scalar>);
static_assert(!RepresentationOf<std::complex<double>, quantity_character::vector>);
static_assert(!RepresentationOf<std::complex<double>, quantity_character::tensor>);
static_assert(!RepresentationOf<cartesian_vector<double>, quantity_character::real_scalar>);
static_assert(!RepresentationOf<cartesian_vector<double>, quantity_character::complex_scalar>);
static_assert(RepresentationOf<cartesian_vector<double>, quantity_character::vector>);
static_assert(!RepresentationOf<cartesian_vector<double>, quantity_character::scalar>);
static_assert(!RepresentationOf<cartesian_vector<double>, quantity_character::complex>);
static_assert(!RepresentationOf<cartesian_vector<double>, quantity_character::complex_scalar>);
static_assert(!RepresentationOf<cartesian_vector<double>, quantity_character::tensor>);
static_assert(!RepresentationOf<std::chrono::seconds, quantity_character::scalar>);
static_assert(!RepresentationOf<std::string, quantity_character::scalar>);
static_assert(!RepresentationOf<cartesian_vector<std::complex<double>>, quantity_character::real_scalar>);
static_assert(!RepresentationOf<cartesian_vector<std::complex<double>>, quantity_character::complex_scalar>);
static_assert(RepresentationOf<cartesian_vector<std::complex<double>>, quantity_character::vector>);
static_assert(!RepresentationOf<cartesian_vector<std::complex<double>>, quantity_character::complex_scalar>);
static_assert(!RepresentationOf<cartesian_vector<std::complex<double>>, quantity_character::tensor>);
static_assert(!RepresentationOf<std::chrono::seconds, quantity_character::real_scalar>);
static_assert(!RepresentationOf<std::string, quantity_character::real_scalar>);
#endif
// Quantity

26
test/static/isq_angle_test.cpp
View File

@ -37,24 +37,24 @@ using enum mp_units::quantity_character;
return q.character == ch && (... && requires { q[units]; });
}
static_assert(verify(isq_angle::cotes_angle_constant, scalar, rad));
static_assert(verify(isq_angle::angular_measure, scalar, rad));
static_assert(verify(isq_angle::rotational_displacement, scalar, rad));
static_assert(verify(isq_angle::angular_displacement, scalar, rad));
static_assert(verify(isq_angle::solid_angular_measure, scalar, sr));
static_assert(verify(isq_angle::cotes_angle_constant, real_scalar, rad));
static_assert(verify(isq_angle::angular_measure, real_scalar, rad));
static_assert(verify(isq_angle::rotational_displacement, real_scalar, rad));
static_assert(verify(isq_angle::angular_displacement, real_scalar, rad));
static_assert(verify(isq_angle::solid_angular_measure, real_scalar, sr));
static_assert(verify(isq_angle::angular_velocity, vector, rad / s));
static_assert(verify(isq_angle::angular_acceleration, vector, rad / s2));
static_assert(verify(isq_angle::rotation, scalar, rad));
static_assert(verify(isq_angle::angular_frequency, scalar, rad / s));
static_assert(verify(isq_angle::angular_repetency, scalar, rad / m));
static_assert(verify(isq_angle::angular_wavenumber, scalar, rad / m));
static_assert(verify(isq_angle::phase_coefficient, scalar, rad / m));
static_assert(verify(isq_angle::propagation_coefficient, scalar, rad / m));
static_assert(verify(isq_angle::rotation, real_scalar, rad));
static_assert(verify(isq_angle::angular_frequency, real_scalar, rad / s));
static_assert(verify(isq_angle::angular_repetency, real_scalar, rad / m));
static_assert(verify(isq_angle::angular_wavenumber, real_scalar, rad / m));
static_assert(verify(isq_angle::phase_coefficient, real_scalar, rad / m));
static_assert(verify(isq_angle::propagation_coefficient, real_scalar, rad / m));
static_assert(verify(isq_angle::moment_of_inertia, tensor, kg* m2 / rad2));
static_assert(verify(isq_angle::angular_momentum, vector, J* s / rad));
static_assert(verify(isq_angle::moment_of_force, vector, J / rad));
static_assert(verify(isq_angle::torque, scalar, J / rad));
static_assert(verify(isq_angle::torque, real_scalar, J / rad));
static_assert(verify(isq_angle::angular_impulse, vector, J* s / rad));
static_assert(verify(isq_angle::loss_angle, scalar, rad));
static_assert(verify(isq_angle::loss_angle, real_scalar, rad));
} // namespace

603
test/static/isq_test.cpp
View File

@ -38,69 +38,69 @@ using enum mp_units::quantity_character;
}
// space and time
static_assert(verify(isq::length, scalar, m));
static_assert(verify(isq::width, scalar, m));
static_assert(verify(isq::breadth, scalar, m));
static_assert(verify(isq::height, scalar, m));
static_assert(verify(isq::depth, scalar, m));
static_assert(verify(isq::altitude, scalar, m));
static_assert(verify(isq::thickness, scalar, m));
static_assert(verify(isq::diameter, scalar, m));
static_assert(verify(isq::radius, scalar, m));
static_assert(verify(isq::path_length, scalar, m));
static_assert(verify(isq::arc_length, scalar, m));
static_assert(verify(isq::distance, scalar, m));
static_assert(verify(isq::radial_distance, scalar, m));
static_assert(verify(isq::length, real_scalar, m));
static_assert(verify(isq::width, real_scalar, m));
static_assert(verify(isq::breadth, real_scalar, m));
static_assert(verify(isq::height, real_scalar, m));
static_assert(verify(isq::depth, real_scalar, m));
static_assert(verify(isq::altitude, real_scalar, m));
static_assert(verify(isq::thickness, real_scalar, m));
static_assert(verify(isq::diameter, real_scalar, m));
static_assert(verify(isq::radius, real_scalar, m));
static_assert(verify(isq::path_length, real_scalar, m));
static_assert(verify(isq::arc_length, real_scalar, m));
static_assert(verify(isq::distance, real_scalar, m));
static_assert(verify(isq::radial_distance, real_scalar, m));
static_assert(verify(isq::position_vector, vector, m));
static_assert(verify(isq::displacement, vector, m));
static_assert(verify(isq::radius_of_curvature, scalar, m));
static_assert(verify(isq::curvature, scalar, one / m));
static_assert(verify(isq::area, scalar, m2));
static_assert(verify(isq::volume, scalar, m3));
static_assert(verify(isq::angular_measure, scalar, rad, one));
static_assert(verify(isq::rotational_displacement, scalar, rad, one));
static_assert(verify(isq::angular_displacement, scalar, rad, one));
static_assert(verify(isq::phase_angle, scalar, rad, one));
static_assert(verify(isq::solid_angular_measure, scalar, sr, one));
static_assert(verify(isq::duration, scalar, s));
static_assert(verify(isq::radius_of_curvature, real_scalar, m));
static_assert(verify(isq::curvature, real_scalar, one / m));
static_assert(verify(isq::area, real_scalar, m2));
static_assert(verify(isq::volume, real_scalar, m3));
static_assert(verify(isq::angular_measure, real_scalar, rad, one));
static_assert(verify(isq::rotational_displacement, real_scalar, rad, one));
static_assert(verify(isq::angular_displacement, real_scalar, rad, one));
static_assert(verify(isq::phase_angle, real_scalar, rad, one));
static_assert(verify(isq::solid_angular_measure, real_scalar, sr, one));
static_assert(verify(isq::duration, real_scalar, s));
static_assert(verify(isq::velocity, vector, m / s));
static_assert(verify(isq::speed, scalar, m / s));
static_assert(verify(isq::speed, real_scalar, m / s));
static_assert(verify(isq::acceleration, vector, m / s2));
static_assert(verify(isq::angular_velocity, vector, rad / s, one / s));
static_assert(verify(isq::angular_acceleration, vector, rad / s2, one / s2));
static_assert(verify(isq::period_duration, scalar, s));
static_assert(verify(isq::duration, scalar, s));
static_assert(verify(isq::time_constant, scalar, s));
static_assert(verify(isq::rotation, scalar, one));
static_assert(verify(isq::frequency, scalar, Hz, one / s));
static_assert(verify(isq::rotational_frequency, scalar, one / s));
static_assert(verify(isq::angular_frequency, scalar, rad / s, one / s));
static_assert(verify(isq::wavelength, scalar, m));
static_assert(verify(isq::repetency, scalar, one / m));
static_assert(verify(isq::wavenumber, scalar, one / m));
static_assert(verify(isq::period_duration, real_scalar, s));
static_assert(verify(isq::duration, real_scalar, s));
static_assert(verify(isq::time_constant, real_scalar, s));
static_assert(verify(isq::rotation, real_scalar, one));
static_assert(verify(isq::frequency, real_scalar, Hz, one / s));
static_assert(verify(isq::rotational_frequency, real_scalar, one / s));
static_assert(verify(isq::angular_frequency, real_scalar, rad / s, one / s));
static_assert(verify(isq::wavelength, real_scalar, m));
static_assert(verify(isq::repetency, real_scalar, one / m));
static_assert(verify(isq::wavenumber, real_scalar, one / m));
static_assert(verify(isq::wave_vector, vector, one / m));
static_assert(verify(isq::angular_repetency, scalar, one / m));
static_assert(verify(isq::angular_wavenumber, scalar, one / m));
static_assert(verify(isq::phase_speed, scalar, m / s));
static_assert(verify(isq::group_speed, scalar, m / s));
static_assert(verify(isq::damping_coefficient, scalar, one / s));
static_assert(verify(isq::logarithmic_decrement, scalar, one));
static_assert(verify(isq::attenuation, scalar, one / m));
static_assert(verify(isq::extinction, scalar, one / m));
static_assert(verify(isq::phase_coefficient, scalar, rad / m, one / m));
static_assert(verify(isq::propagation_coefficient, scalar, one / m));
static_assert(verify(isq::angular_repetency, real_scalar, one / m));
static_assert(verify(isq::angular_wavenumber, real_scalar, one / m));
static_assert(verify(isq::phase_speed, real_scalar, m / s));
static_assert(verify(isq::group_speed, real_scalar, m / s));
static_assert(verify(isq::damping_coefficient, real_scalar, one / s));
static_assert(verify(isq::logarithmic_decrement, real_scalar, one));
static_assert(verify(isq::attenuation, real_scalar, one / m));
static_assert(verify(isq::extinction, real_scalar, one / m));
static_assert(verify(isq::phase_coefficient, real_scalar, rad / m, one / m));
static_assert(verify(isq::propagation_coefficient, real_scalar, one / m));
// mechanics
static_assert(verify(isq::mass, scalar, kg));
static_assert(verify(isq::mass_density, scalar, kg / m3));
static_assert(verify(isq::density, scalar, kg / m3));
static_assert(verify(isq::specific_volume, scalar, m3 / kg));
static_assert(verify(isq::relative_mass_density, scalar, one));
static_assert(verify(isq::relative_density, scalar, one));
static_assert(verify(isq::surface_mass_density, scalar, kg / m2));
static_assert(verify(isq::surface_density, scalar, kg / m2));
static_assert(verify(isq::linear_mass_density, scalar, kg / m));
static_assert(verify(isq::linear_density, scalar, kg / m));
static_assert(verify(isq::mass, real_scalar, kg));
static_assert(verify(isq::mass_density, real_scalar, kg / m3));
static_assert(verify(isq::density, real_scalar, kg / m3));
static_assert(verify(isq::specific_volume, real_scalar, m3 / kg));
static_assert(verify(isq::relative_mass_density, real_scalar, one));
static_assert(verify(isq::relative_density, real_scalar, one));
static_assert(verify(isq::surface_mass_density, real_scalar, kg / m2));
static_assert(verify(isq::surface_density, real_scalar, kg / m2));
static_assert(verify(isq::linear_mass_density, real_scalar, kg / m));
static_assert(verify(isq::linear_density, real_scalar, kg / m));
static_assert(verify(isq::moment_of_inertia, tensor, kg* m2));
static_assert(verify(isq::momentum, vector, kg* m / s));
static_assert(verify(isq::force, vector, N, kg* m / s2));
@ -116,285 +116,286 @@ static_assert(verify(isq::drag_force, vector, N, kg* m / s2));
static_assert(verify(isq::impulse, vector, N* s, kg* m / s));
static_assert(verify(isq::angular_momentum, vector, kg* m2 / s));
static_assert(verify(isq::moment_of_force, vector, N* m, kg* m2 / s2));
static_assert(verify(isq::torque, scalar, N* m, kg* m2 / s2));
static_assert(verify(isq::torque, real_scalar, N* m, kg* m2 / s2));
static_assert(verify(isq::angular_impulse, vector, N* m* s, kg* m2 / s));
static_assert(verify(isq::pressure, scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::gauge_pressure, scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::pressure, real_scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::gauge_pressure, real_scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::stress, tensor, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::normal_stress, scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::shear_stress, scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::normal_stress, real_scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::shear_stress, real_scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::strain, tensor, one));
static_assert(verify(isq::relative_linear_strain, scalar, one));
static_assert(verify(isq::shear_strain, scalar, one));
static_assert(verify(isq::relative_volume_strain, scalar, one));
static_assert(verify(isq::Poisson_number, scalar, one));
static_assert(verify(isq::modulus_of_elasticity, scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::Young_modulus, scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::modulus_of_rigidity, scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::shear_modulus, scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::modulus_of_compression, scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::bulk_modulus, scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::compressibility, scalar, one / Pa, m* s2 / kg));
static_assert(verify(isq::second_axial_moment_of_area, scalar, m4));
static_assert(verify(isq::second_polar_moment_of_area, scalar, m4));
static_assert(verify(isq::section_modulus, scalar, m3));
static_assert(verify(isq::static_friction_coefficient, scalar, one));
static_assert(verify(isq::static_friction_factor, scalar, one));
static_assert(verify(isq::coefficient_of_static_friction, scalar, one));
static_assert(verify(isq::kinetic_friction_factor, scalar, one));
static_assert(verify(isq::dynamic_friction_factor, scalar, one));
static_assert(verify(isq::rolling_resistance_factor, scalar, one));
static_assert(verify(isq::drag_coefficient, scalar, one));
static_assert(verify(isq::drag_factor, scalar, one));
static_assert(verify(isq::dynamic_viscosity, scalar, Pa* s, kg / m / s));
static_assert(verify(isq::kinematic_viscosity, scalar, m2 / s));
static_assert(verify(isq::surface_tension, scalar, N / m, kg / s2));
static_assert(verify(isq::power, scalar, W, N* m / s, kg* m2 / s3));
static_assert(verify(isq::potential_energy, scalar, J, kg* m2 / s2));
static_assert(verify(isq::kinetic_energy, scalar, J, kg* m2 / s2));
static_assert(verify(isq::mechanical_energy, scalar, J, kg* m2 / s2));
static_assert(verify(isq::mechanical_work, scalar, J, kg* m2 / s2));
static_assert(verify(isq::work, scalar, J, kg* m2 / s2));
static_assert(verify(isq::mechanical_efficiency, scalar, one));
static_assert(verify(isq::relative_linear_strain, real_scalar, one));
static_assert(verify(isq::shear_strain, real_scalar, one));
static_assert(verify(isq::relative_volume_strain, real_scalar, one));
static_assert(verify(isq::Poisson_number, real_scalar, one));
static_assert(verify(isq::modulus_of_elasticity, real_scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::Young_modulus, real_scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::modulus_of_rigidity, real_scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::shear_modulus, real_scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::modulus_of_compression, real_scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::bulk_modulus, real_scalar, Pa, N / m2, kg / m / s2));
static_assert(verify(isq::compressibility, real_scalar, one / Pa, m* s2 / kg));
static_assert(verify(isq::second_axial_moment_of_area, real_scalar, m4));
static_assert(verify(isq::second_polar_moment_of_area, real_scalar, m4));
static_assert(verify(isq::section_modulus, real_scalar, m3));
static_assert(verify(isq::static_friction_coefficient, real_scalar, one));
static_assert(verify(isq::static_friction_factor, real_scalar, one));
static_assert(verify(isq::coefficient_of_static_friction, real_scalar, one));
static_assert(verify(isq::kinetic_friction_factor, real_scalar, one));
static_assert(verify(isq::dynamic_friction_factor, real_scalar, one));
static_assert(verify(isq::rolling_resistance_factor, real_scalar, one));
static_assert(verify(isq::drag_coefficient, real_scalar, one));
static_assert(verify(isq::drag_factor, real_scalar, one));
static_assert(verify(isq::dynamic_viscosity, real_scalar, Pa* s, kg / m / s));
static_assert(verify(isq::kinematic_viscosity, real_scalar, m2 / s));
static_assert(verify(isq::surface_tension, real_scalar, N / m, kg / s2));
static_assert(verify(isq::power, real_scalar, W, N* m / s, kg* m2 / s3));
static_assert(verify(isq::potential_energy, real_scalar, J, kg* m2 / s2));
static_assert(verify(isq::kinetic_energy, real_scalar, J, kg* m2 / s2));
static_assert(verify(isq::mechanical_energy, real_scalar, J, kg* m2 / s2));
static_assert(verify(isq::mechanical_work, real_scalar, J, kg* m2 / s2));
static_assert(verify(isq::work, real_scalar, J, kg* m2 / s2));
static_assert(verify(isq::mechanical_efficiency, real_scalar, one));
static_assert(verify(isq::mass_flow, vector, kg / m2 / s));
static_assert(verify(isq::mass_flow_rate, scalar, kg / s));
static_assert(verify(isq::mass_change_rate, scalar, kg / s));
static_assert(verify(isq::volume_flow_rate, scalar, m3 / s));
static_assert(verify(isq::action, scalar, J* s, kg* m2 / s));
static_assert(verify(isq::mass_flow_rate, real_scalar, kg / s));
static_assert(verify(isq::mass_change_rate, real_scalar, kg / s));
static_assert(verify(isq::volume_flow_rate, real_scalar, m3 / s));
static_assert(verify(isq::action, real_scalar, J* s, kg* m2 / s));
// thermodynamics
static_assert(verify(isq::thermodynamic_temperature, scalar, K));
static_assert(verify(isq::Celsius_temperature, scalar, deg_C));
static_assert(verify(isq::linear_expansion_coefficient, scalar, one / K));
static_assert(verify(isq::cubic_expansion_coefficient, scalar, one / K));
static_assert(verify(isq::relative_pressure_coefficient, scalar, one / K));
static_assert(verify(isq::pressure_coefficient, scalar, Pa / K, kg / m / s2 / K));
static_assert(verify(isq::isothermal_compressibility, scalar, one / Pa, m* s2 / kg));
static_assert(verify(isq::isentropic_compressibility, scalar, one / Pa, m* s2 / kg));
static_assert(verify(isq::heat, scalar, J, kg* m2 / s2));
static_assert(verify(isq::amount_of_heat, scalar, J, kg* m2 / s2));
static_assert(verify(isq::latent_heat, scalar, J, kg* m2 / s2));
static_assert(verify(isq::heat_flow_rate, scalar, W, J / s, kg* m2 / s3));
static_assert(verify(isq::density_of_heat_flow_rate, scalar, W / m2, kg / s3));
static_assert(verify(isq::thermal_conductivity, scalar, W / (m * K), kg* m / s3 / K));
static_assert(verify(isq::coefficient_of_heat_transfer, scalar, W / (m2 * K), kg / s3 / K));
static_assert(verify(isq::surface_coefficient_of_heat_transfer, scalar, W / (m2 * K), kg / s3 / K));
static_assert(verify(isq::thermal_insulance, scalar, m2* K / W, s3* K / kg));
static_assert(verify(isq::thermal_resistance, scalar, K / W, s3* K / kg / m2));
static_assert(verify(isq::thermal_conductance, scalar, W / K, kg* m2 / s3 / K));
static_assert(verify(isq::thermal_diffusivity, scalar, m2 / s));
static_assert(verify(isq::heat_capacity, scalar, J / K, kg* m2 / s2 / K));
static_assert(verify(isq::specific_heat_capacity, scalar, J / (kg * K), m2 / s2 / K));
static_assert(verify(isq::specific_heat_capacity_at_constant_pressure, scalar, J / (kg * K), m2 / s2 / K));
static_assert(verify(isq::specific_heat_capacity_at_constant_volume, scalar, J / (kg * K), m2 / s2 / K));
static_assert(verify(isq::specific_heat_capacity_at_saturated_vapour_pressure, scalar, J / (kg * K), m2 / s2 / K));
static_assert(verify(isq::ratio_of_specific_heat_capacities, scalar, one));
static_assert(verify(isq::isentropic_exponent, scalar, one));
static_assert(verify(isq::isentropic_expansion_factor, scalar, one));
static_assert(verify(isq::entropy, scalar, J / K, kg* m2 / s2 / K));
static_assert(verify(isq::specific_entropy, scalar, J / (kg * K), m2 / s2 / K));
static_assert(verify(isq::energy, scalar, J, kg* m2 / s2));
static_assert(verify(isq::internal_energy, scalar, J, kg* m2 / s2));
static_assert(verify(isq::thermodynamic_energy, scalar, J, kg* m2 / s2));
static_assert(verify(isq::enthalpy, scalar, J, kg* m2 / s2));
static_assert(verify(isq::Helmholtz_energy, scalar, J, kg* m2 / s2));
static_assert(verify(isq::Helmholtz_function, scalar, J, kg* m2 / s2));
static_assert(verify(isq::Gibbs_energy, scalar, J, kg* m2 / s2));
static_assert(verify(isq::Gibbs_function, scalar, J, kg* m2 / s2));
static_assert(verify(isq::specific_energy, scalar, J / kg, m2 / s2));
static_assert(verify(isq::specific_internal_energy, scalar, J / kg, m2 / s2));
static_assert(verify(isq::specific_thermodynamic_energy, scalar, J / kg, m2 / s2));
static_assert(verify(isq::specific_enthalpy, scalar, J / kg, m2 / s2));
static_assert(verify(isq::specific_Helmholtz_energy, scalar, J / kg, m2 / s2));
static_assert(verify(isq::specific_Helmholtz_function, scalar, J / kg, m2 / s2));
static_assert(verify(isq::specific_Gibbs_energy, scalar, J / kg, m2 / s2));
static_assert(verify(isq::specific_Gibbs_function, scalar, J / kg, m2 / s2));
static_assert(verify(isq::Massieu_function, scalar, J / K, kg* m2 / s2 / K));
static_assert(verify(isq::Planck_function, scalar, J / K, kg* m2 / s2 / K));
static_assert(verify(isq::Joule_Thomson_coefficient, scalar, K / Pa, m* s2* K / kg));
static_assert(verify(isq::thermodynamic_efficiency, scalar, one));
static_assert(verify(isq::maximum_efficiency, scalar, one));
static_assert(verify(isq::specific_gas_constant, scalar, J / (kg * K), m2 / s2 / K));
static_assert(verify(isq::mass_concentration_of_water, scalar, kg / m3));
static_assert(verify(isq::mass_concentration_of_water_vapour, scalar, kg / m3));
static_assert(verify(isq::mass_ratio_of_water_to_dry_matter, scalar, one));
static_assert(verify(isq::mass_ratio_of_water_vapour_to_dry_gas, scalar, one));
static_assert(verify(isq::mass_fraction_of_water, scalar, one));
static_assert(verify(isq::mass_fraction_of_dry_matter, scalar, one));
static_assert(verify(isq::relative_humidity, scalar, one));
static_assert(verify(isq::relative_mass_concentration_of_vapour, scalar, one));
static_assert(verify(isq::relative_mass_ratio_of_vapour, scalar, one));
static_assert(verify(isq::dew_point_temperature, scalar, K));
static_assert(verify(isq::thermodynamic_temperature, real_scalar, K));
static_assert(verify(isq::Celsius_temperature, real_scalar, deg_C));
static_assert(verify(isq::linear_expansion_coefficient, real_scalar, one / K));
static_assert(verify(isq::cubic_expansion_coefficient, real_scalar, one / K));
static_assert(verify(isq::relative_pressure_coefficient, real_scalar, one / K));
static_assert(verify(isq::pressure_coefficient, real_scalar, Pa / K, kg / m / s2 / K));
static_assert(verify(isq::isothermal_compressibility, real_scalar, one / Pa, m* s2 / kg));
static_assert(verify(isq::isentropic_compressibility, real_scalar, one / Pa, m* s2 / kg));
static_assert(verify(isq::heat, real_scalar, J, kg* m2 / s2));
static_assert(verify(isq::amount_of_heat, real_scalar, J, kg* m2 / s2));
static_assert(verify(isq::latent_heat, real_scalar, J, kg* m2 / s2));
static_assert(verify(isq::heat_flow_rate, real_scalar, W, J / s, kg* m2 / s3));
static_assert(verify(isq::density_of_heat_flow_rate, real_scalar, W / m2, kg / s3));
static_assert(verify(isq::thermal_conductivity, real_scalar, W / (m * K), kg* m / s3 / K));
static_assert(verify(isq::coefficient_of_heat_transfer, real_scalar, W / (m2 * K), kg / s3 / K));
static_assert(verify(isq::surface_coefficient_of_heat_transfer, real_scalar, W / (m2 * K), kg / s3 / K));
static_assert(verify(isq::thermal_insulance, real_scalar, m2* K / W, s3* K / kg));
static_assert(verify(isq::thermal_resistance, real_scalar, K / W, s3* K / kg / m2));
static_assert(verify(isq::thermal_conductance, real_scalar, W / K, kg* m2 / s3 / K));
static_assert(verify(isq::thermal_diffusivity, real_scalar, m2 / s));
static_assert(verify(isq::heat_capacity, real_scalar, J / K, kg* m2 / s2 / K));
static_assert(verify(isq::specific_heat_capacity, real_scalar, J / (kg * K), m2 / s2 / K));
static_assert(verify(isq::specific_heat_capacity_at_constant_pressure, real_scalar, J / (kg * K), m2 / s2 / K));
static_assert(verify(isq::specific_heat_capacity_at_constant_volume, real_scalar, J / (kg * K), m2 / s2 / K));
static_assert(verify(isq::specific_heat_capacity_at_saturated_vapour_pressure, real_scalar, J / (kg * K), m2 / s2 / K));
static_assert(verify(isq::ratio_of_specific_heat_capacities, real_scalar, one));
static_assert(verify(isq::isentropic_exponent, real_scalar, one));
static_assert(verify(isq::isentropic_expansion_factor, real_scalar, one));
static_assert(verify(isq::entropy, real_scalar, J / K, kg* m2 / s2 / K));
static_assert(verify(isq::specific_entropy, real_scalar, J / (kg * K), m2 / s2 / K));
static_assert(verify(isq::energy, real_scalar, J, kg* m2 / s2));
static_assert(verify(isq::internal_energy, real_scalar, J, kg* m2 / s2));
static_assert(verify(isq::thermodynamic_energy, real_scalar, J, kg* m2 / s2));
static_assert(verify(isq::enthalpy, real_scalar, J, kg* m2 / s2));
static_assert(verify(isq::Helmholtz_energy, real_scalar, J, kg* m2 / s2));
static_assert(verify(isq::Helmholtz_function, real_scalar, J, kg* m2 / s2));
static_assert(verify(isq::Gibbs_energy, real_scalar, J, kg* m2 / s2));
static_assert(verify(isq::Gibbs_function, real_scalar, J, kg* m2 / s2));
static_assert(verify(isq::specific_energy, real_scalar, J / kg, m2 / s2));
static_assert(verify(isq::specific_internal_energy, real_scalar, J / kg, m2 / s2));
static_assert(verify(isq::specific_thermodynamic_energy, real_scalar, J / kg, m2 / s2));
static_assert(verify(isq::specific_enthalpy, real_scalar, J / kg, m2 / s2));
static_assert(verify(isq::specific_Helmholtz_energy, real_scalar, J / kg, m2 / s2));
static_assert(verify(isq::specific_Helmholtz_function, real_scalar, J / kg, m2 / s2));
static_assert(verify(isq::specific_Gibbs_energy, real_scalar, J / kg, m2 / s2));
static_assert(verify(isq::specific_Gibbs_function, real_scalar, J / kg, m2 / s2));
static_assert(verify(isq::Massieu_function, real_scalar, J / K, kg* m2 / s2 / K));
static_assert(verify(isq::Planck_function, real_scalar, J / K, kg* m2 / s2 / K));
static_assert(verify(isq::Joule_Thomson_coefficient, real_scalar, K / Pa, m* s2* K / kg));
static_assert(verify(isq::thermodynamic_efficiency, real_scalar, one));
static_assert(verify(isq::maximum_efficiency, real_scalar, one));
static_assert(verify(isq::specific_gas_constant, real_scalar, J / (kg * K), m2 / s2 / K));
static_assert(verify(isq::mass_concentration_of_water, real_scalar, kg / m3));
static_assert(verify(isq::mass_concentration_of_water_vapour, real_scalar, kg / m3));
static_assert(verify(isq::mass_ratio_of_water_to_dry_matter, real_scalar, one));
static_assert(verify(isq::mass_ratio_of_water_vapour_to_dry_gas, real_scalar, one));
static_assert(verify(isq::mass_fraction_of_water, real_scalar, one));
static_assert(verify(isq::mass_fraction_of_dry_matter, real_scalar, one));
static_assert(verify(isq::relative_humidity, real_scalar, one));
static_assert(verify(isq::relative_mass_concentration_of_vapour, real_scalar, one));
static_assert(verify(isq::relative_mass_ratio_of_vapour, real_scalar, one));
static_assert(verify(isq::dew_point_temperature, real_scalar, K));
// electromagnetism
static_assert(verify(isq::electric_current, scalar, A));
static_assert(verify(isq::electric_charge, scalar, C, A* s));
static_assert(verify(isq::elementary_charge, scalar, C, A* s));
static_assert(verify(isq::electric_charge_density, scalar, C / m3, s* A / m3));
static_assert(verify(isq::volume_electric_charge, scalar, C / m3, s* A / m3));
static_assert(verify(isq::volumic_charge, scalar, C / m3, s* A / m3));
static_assert(verify(isq::surface_density_of_electric_charge, scalar, C / m2, s* A / m2));
static_assert(verify(isq::areic_electric_charge, scalar, C / m2, s* A / m2));
static_assert(verify(isq::areic_charge, scalar, C / m2, s* A / m2));
static_assert(verify(isq::linear_density_of_electric_charge, scalar, C / m, s* A / m));
static_assert(verify(isq::lineic_electric_charge, scalar, C / m, s* A / m));
static_assert(verify(isq::lineic_charge, scalar, C / m, s* A / m));
static_assert(verify(isq::electric_current, real_scalar, A));
static_assert(verify(isq::electric_charge, real_scalar, C, A* s));
static_assert(verify(isq::elementary_charge, real_scalar, C, A* s));
static_assert(verify(isq::electric_charge_density, real_scalar, C / m3, s* A / m3));
static_assert(verify(isq::volume_electric_charge, real_scalar, C / m3, s* A / m3));
static_assert(verify(isq::volumic_charge, real_scalar, C / m3, s* A / m3));
static_assert(verify(isq::surface_density_of_electric_charge, real_scalar, C / m2, s* A / m2));
static_assert(verify(isq::areic_electric_charge, real_scalar, C / m2, s* A / m2));
static_assert(verify(isq::areic_charge, real_scalar, C / m2, s* A / m2));
static_assert(verify(isq::linear_density_of_electric_charge, real_scalar, C / m, s* A / m));
static_assert(verify(isq::lineic_electric_charge, real_scalar, C / m, s* A / m));
static_assert(verify(isq::lineic_charge, real_scalar, C / m, s* A / m));
static_assert(verify(isq::electric_dipole_moment, vector, C* m, m* s* A));
static_assert(verify(isq::electric_polarization, vector, C / m2, s* A / m2));
static_assert(verify(isq::electric_current_density, vector, A / m2));
static_assert(verify(isq::linear_electric_current_density, vector, A / m));
static_assert(verify(isq::electric_field_strength, vector, V / m, kg* m / (s3 * A)));
static_assert(verify(isq::electric_potential, scalar, V, kg* m2 / (s3 * A)));
static_assert(verify(isq::electric_potential_difference, scalar, V, kg* m2 / (s3 * A)));
static_assert(verify(isq::voltage, scalar, V, kg* m2 / (s3 * A)));
static_assert(verify(isq::electric_tension, scalar, V, kg* m2 / (s3 * A)));
static_assert(verify(isq::induced_voltage, scalar, V, kg* m2 / (s3 * A)));
static_assert(verify(isq::electric_potential, real_scalar, V, kg* m2 / (s3 * A)));
static_assert(verify(isq::electric_potential_difference, real_scalar, V, kg* m2 / (s3 * A)));
static_assert(verify(isq::voltage, real_scalar, V, kg* m2 / (s3 * A)));
static_assert(verify(isq::electric_tension, real_scalar, V, kg* m2 / (s3 * A)));
static_assert(verify(isq::induced_voltage, real_scalar, V, kg* m2 / (s3 * A)));
static_assert(verify(isq::electric_flux_density, vector, C / m2, s* A / m2));
static_assert(verify(isq::electric_displacement, vector, C / m2, s* A / m2));
static_assert(verify(isq::capacitance, scalar, F, pow<4>(s) * square(A) / (kg * m2)));
static_assert(verify(isq::electric_constant, scalar, F / m, pow<4>(s) * square(A) / (kg * m3)));
static_assert(verify(isq::permittivity_of_vacuum, scalar, F / m, pow<4>(s) * square(A) / (kg * m3)));
static_assert(verify(isq::permittivity, scalar, F / m, pow<4>(s) * square(A) / (kg * m3)));
static_assert(verify(isq::relative_permittivity, scalar, one));
static_assert(verify(isq::electric_susceptibility, scalar, one));
static_assert(verify(isq::electric_flux, scalar, C, s* A));
static_assert(verify(isq::capacitance, real_scalar, F, pow<4>(s) * square(A) / (kg * m2)));
static_assert(verify(isq::electric_constant, real_scalar, F / m, pow<4>(s) * square(A) / (kg * m3)));
static_assert(verify(isq::permittivity_of_vacuum, real_scalar, F / m, pow<4>(s) * square(A) / (kg * m3)));
static_assert(verify(isq::permittivity, real_scalar, F / m, pow<4>(s) * square(A) / (kg * m3)));
static_assert(verify(isq::relative_permittivity, real_scalar, one));
static_assert(verify(isq::electric_susceptibility, real_scalar, one));
static_assert(verify(isq::electric_flux, real_scalar, C, s* A));
static_assert(verify(isq::displacement_current_density, vector, A / m2));
static_assert(verify(isq::displacement_current, scalar, A));
static_assert(verify(isq::total_current, scalar, A));
static_assert(verify(isq::displacement_current, real_scalar, A));
static_assert(verify(isq::total_current, real_scalar, A));
static_assert(verify(isq::total_current_density, vector, A / m2));
static_assert(verify(isq::magnetic_flux_density, vector, T, kg / (s2 * A)));
static_assert(verify(isq::magnetic_flux, scalar, Wb, kg* m2 / (s2 * A)));
static_assert(verify(isq::protoflux, scalar, Wb, kg* m2 / (s2 * A)));
static_assert(verify(isq::linked_magnetic_flux, scalar, Wb, kg* m2 / (s2 * A)));
static_assert(verify(isq::total_magnetic_flux, scalar, Wb, kg* m2 / (s2 * A)));
static_assert(verify(isq::magnetic_flux, real_scalar, Wb, kg* m2 / (s2 * A)));
static_assert(verify(isq::protoflux, real_scalar, Wb, kg* m2 / (s2 * A)));
static_assert(verify(isq::linked_magnetic_flux, real_scalar, Wb, kg* m2 / (s2 * A)));
static_assert(verify(isq::total_magnetic_flux, real_scalar, Wb, kg* m2 / (s2 * A)));
static_assert(verify(isq::magnetic_moment, vector, A* m2));
static_assert(verify(isq::magnetic_area_moment, vector, A* m2));
static_assert(verify(isq::magnetization, vector, A / m));
static_assert(verify(isq::magnetic_field_strength, vector, A / m));
static_assert(verify(isq::magnetizing_field, vector, A / m));
static_assert(verify(isq::magnetic_constant, scalar, H / m, kg* m / (s2 * square(A))));
static_assert(verify(isq::permeability_of_vacuum, scalar, H / m, kg* m / (s2 * square(A))));
static_assert(verify(isq::permeability, scalar, H / m, kg* m / (s2 * square(A))));
static_assert(verify(isq::relative_permeability, scalar, one));
static_assert(verify(isq::magnetic_susceptibility, scalar, one));
static_assert(verify(isq::magnetic_constant, real_scalar, H / m, kg* m / (s2 * square(A))));
static_assert(verify(isq::permeability_of_vacuum, real_scalar, H / m, kg* m / (s2 * square(A))));
static_assert(verify(isq::permeability, real_scalar, H / m, kg* m / (s2 * square(A))));
static_assert(verify(isq::relative_permeability, real_scalar, one));
static_assert(verify(isq::magnetic_susceptibility, real_scalar, one));
static_assert(verify(isq::magnetic_polarization, vector, T, Wb / m2, kg / (s2 * A)));
static_assert(verify(isq::magnetic_dipole_moment, vector, Wb* m, kg* m3 / (s2 * A)));
static_assert(verify(isq::coercivity, scalar, A / m));
static_assert(verify(isq::coercive_field_strength, scalar, A / m));
static_assert(verify(isq::coercivity, real_scalar, A / m));
static_assert(verify(isq::coercive_field_strength, real_scalar, A / m));
static_assert(verify(isq::magnetic_vector_potential, vector, J / (A * m), kg* m / (s2 * A)));
static_assert(verify(isq::electromagnetic_energy_density, scalar, J / m3, kg / (m * s2)));
static_assert(verify(isq::electromagnetic_energy_density, real_scalar, J / m3, kg / (m * s2)));
static_assert(verify(isq::Poynting_vector, vector, W / m2, kg / s3));
static_assert(verify(isq::phase_speed_of_electromagnetic_waves, scalar, m / s));
static_assert(verify(isq::speed_of_light_in_vacuum, scalar, m / s));
static_assert(verify(isq::light_speed_in_vacuum, scalar, m / s));
static_assert(verify(isq::luminal_speed, scalar, m / s));
static_assert(verify(isq::source_voltage, scalar, V, kg* m2 / (s3 * A)));
static_assert(verify(isq::source_tension, scalar, V, kg* m2 / (s3 * A)));
static_assert(verify(isq::magnetic_potential, scalar, A));
static_assert(verify(isq::magnetic_tension, scalar, A));
static_assert(verify(isq::magnetomotive_force, scalar, A));
static_assert(verify(isq::number_of_turns_in_a_winding, scalar, one));
static_assert(verify(isq::reluctance, scalar, one / H, s2* square(A) / (kg * m2)));
static_assert(verify(isq::permeance, scalar, H, kg* m2 / (s2 * square(A))));
static_assert(verify(isq::inductance, scalar, H, kg* m2 / (s2 * square(A))));
static_assert(verify(isq::self_inductance, scalar, H, kg* m2 / (s2 * square(A))));
static_assert(verify(isq::mutual_inductance, scalar, H, kg* m2 / (s2 * square(A))));
static_assert(verify(isq::coupling_factor, scalar, one));
static_assert(verify(isq::leakage_factor, scalar, one));
static_assert(verify(isq::conductivity, scalar, S / m, s3* square(A) / (kg * m3)));
static_assert(verify(isq::resistivity, scalar, Ω* m, kg* m3 / (s3 * square(A))));
static_assert(verify(isq::electromagnetism_power, scalar, W, kg* m2 / s3));
static_assert(verify(isq::instantaneous_power, scalar, W, kg* m2 / s3));
static_assert(verify(isq::resistance, scalar, Ω, kg* m2 / (s3 * square(A))));
static_assert(verify(isq::conductance, scalar, S, s3* square(A) / (kg * m2)));
static_assert(verify(isq::phase_difference, scalar, rad, one));
static_assert(verify(isq::electric_current_phasor, complex, A));
static_assert(verify(isq::voltage_phasor, complex, V, kg* m2 / (s3 * A)));
static_assert(verify(isq::electric_tension_phasor, complex, V, kg* m2 / (s3 * A)));
static_assert(verify(isq::impedance, scalar, Ω, kg* m2 / (s3 * square(A))));
static_assert(verify(isq::complex_impedance, scalar, Ω, kg* m2 / (s3 * square(A))));
static_assert(verify(isq::impedance_of_vacuum, scalar, V / A, kg* m2 / (s3 * square(A))));
static_assert(verify(isq::wave_impedance_in_vacuum, scalar, V / A, kg* m2 / (s3 * square(A))));
static_assert(verify(isq::resistance_to_alternating_current, scalar, Ω, kg* m2 / (s3 * square(A))));
static_assert(verify(isq::reactance, scalar, Ω, kg* m2 / (s3 * square(A))));
static_assert(verify(isq::apparent_impedance, scalar, Ω, kg* m2 / (s3 * square(A))));
static_assert(verify(isq::admittance, scalar, S, s3* square(A) / (kg * m2)));
static_assert(verify(isq::complex_admittance, scalar, S, s3* square(A) / (kg * m2)));
static_assert(verify(isq::admittance_of_vacuum, scalar, A / V, s3* square(A) / (kg * m2)));
static_assert(verify(isq::conductance_for_alternating_current, scalar, S, s3* square(A) / (kg * m2)));
static_assert(verify(isq::susceptance, scalar, S, s3* square(A) / (kg * m2)));
static_assert(verify(isq::apparent_admittance, scalar, S, s3* square(A) / (kg * m2)));
static_assert(verify(isq::quality_factor, scalar, one));
static_assert(verify(isq::loss_factor, scalar, one));
static_assert(verify(isq::loss_angle, scalar, rad, one));
static_assert(verify(isq::active_power, scalar, W, kg* m2 / s3));
static_assert(verify(isq::apparent_power, scalar, V* A, kg* m2 / s3));
static_assert(verify(isq::power_factor, scalar, one));
static_assert(verify(isq::complex_power, complex, V* A, kg* m2 / s3));
static_assert(verify(isq::reactive_power, scalar, var, V* A, kg* m2 / s3));
static_assert(verify(isq::non_active_power, scalar, V* A, kg* m2 / s3));
static_assert(verify(isq::active_energy, scalar, J, W* s, kg* m2 / s2));
static_assert(verify(isq::phase_speed_of_electromagnetic_waves, real_scalar, m / s));
static_assert(verify(isq::speed_of_light_in_vacuum, real_scalar, m / s));
static_assert(verify(isq::light_speed_in_vacuum, real_scalar, m / s));
static_assert(verify(isq::luminal_speed, real_scalar, m / s));
static_assert(verify(isq::source_voltage, real_scalar, V, kg* m2 / (s3 * A)));
static_assert(verify(isq::source_tension, real_scalar, V, kg* m2 / (s3 * A)));
static_assert(verify(isq::magnetic_potential, real_scalar, A));
static_assert(verify(isq::magnetic_tension, real_scalar, A));
static_assert(verify(isq::magnetomotive_force, real_scalar, A));
static_assert(verify(isq::number_of_turns_in_a_winding, real_scalar, one));
static_assert(verify(isq::reluctance, real_scalar, one / H, s2* square(A) / (kg * m2)));
static_assert(verify(isq::permeance, real_scalar, H, kg* m2 / (s2 * square(A))));
static_assert(verify(isq::inductance, real_scalar, H, kg* m2 / (s2 * square(A))));
static_assert(verify(isq::self_inductance, real_scalar, H, kg* m2 / (s2 * square(A))));
static_assert(verify(isq::mutual_inductance, real_scalar, H, kg* m2 / (s2 * square(A))));
static_assert(verify(isq::coupling_factor, real_scalar, one));
static_assert(verify(isq::leakage_factor, real_scalar, one));
static_assert(verify(isq::conductivity, real_scalar, S / m, s3* square(A) / (kg * m3)));
static_assert(verify(isq::resistivity, real_scalar, Ω* m, kg* m3 / (s3 * square(A))));
static_assert(verify(isq::electromagnetism_power, real_scalar, W, kg* m2 / s3));
static_assert(verify(isq::instantaneous_power, real_scalar, W, kg* m2 / s3));
static_assert(verify(isq::resistance, real_scalar, Ω, kg* m2 / (s3 * square(A))));
static_assert(verify(isq::conductance, real_scalar, S, s3* square(A) / (kg * m2)));
static_assert(verify(isq::phase_difference, real_scalar, rad, one));
static_assert(verify(isq::electric_current_phasor, complex_scalar, A));
static_assert(verify(isq::voltage_phasor, complex_scalar, V, kg* m2 / (s3 * A)));
static_assert(verify(isq::electric_tension_phasor, complex_scalar, V, kg* m2 / (s3 * A)));
static_assert(verify(isq::impedance, complex_scalar, Ω, kg* m2 / (s3 * square(A))));
static_assert(verify(isq::complex_impedance, complex_scalar, Ω, kg* m2 / (s3 * square(A))));
static_assert(verify(isq::impedance_of_vacuum, complex_scalar, V / A, kg* m2 / (s3 * square(A))));
static_assert(verify(isq::wave_impedance_in_vacuum, complex_scalar, V / A, kg* m2 / (s3 * square(A))));
static_assert(verify(isq::resistance_to_alternating_current, real_scalar, Ω, kg* m2 / (s3 * square(A))));
static_assert(verify(isq::reactance, real_scalar, Ω, kg* m2 / (s3 * square(A))));
static_assert(verify(isq::apparent_impedance, real_scalar, Ω, kg* m2 / (s3 * square(A))));
static_assert(verify(isq::admittance, complex_scalar, S, s3* square(A) / (kg * m2)));
static_assert(verify(isq::complex_admittance, complex_scalar, S, s3* square(A) / (kg * m2)));
static_assert(verify(isq::admittance_of_vacuum, complex_scalar, A / V, s3* square(A) / (kg * m2)));
static_assert(verify(isq::conductance_for_alternating_current, real_scalar, S, s3* square(A) / (kg * m2)));
static_assert(verify(isq::susceptance, real_scalar, S, s3* square(A) / (kg * m2)));
static_assert(verify(isq::apparent_admittance, real_scalar, S, s3* square(A) / (kg * m2)));
static_assert(verify(isq::quality_factor, real_scalar, one));
static_assert(verify(isq::loss_factor, real_scalar, one));
static_assert(verify(isq::loss_angle, real_scalar, rad, one));
static_assert(verify(isq::active_power, real_scalar, W, kg* m2 / s3));
static_assert(verify(isq::apparent_power, real_scalar, V* A, kg* m2 / s3));
static_assert(verify(isq::power_factor, real_scalar, one));
static_assert(verify(isq::complex_power, complex_scalar, V* A, kg* m2 / s3));
static_assert(verify(isq::reactive_power, real_scalar, var, V* A, kg* m2 / s3));
static_assert(verify(isq::non_active_power, real_scalar, V* A, kg* m2 / s3));
static_assert(verify(isq::active_energy, real_scalar, J, W* s, kg* m2 / s2));
// light and radiation
static_assert(verify(isq::speed_of_light_in_a_medium, scalar, m / s));
static_assert(verify(isq::refractive_index, scalar, one));
static_assert(verify(isq::radiant_energy, scalar, J, kg* m2 / s2));
static_assert(verify(isq::spectral_radiant_energy, scalar, J / nm, kg* m / s2));
static_assert(verify(isq::radiant_energy_density, scalar, J / m3, kg / m / s2));
static_assert(verify(isq::spectral_radiant_energy_density_in_terms_of_wavelength, scalar, J / (m3 * nm), kg / m2 / s2));
static_assert(verify(isq::spectral_radiant_energy_density_in_terms_of_wavenumber, scalar, J / m2, kg / s2));
static_assert(verify(isq::radiant_flux, scalar, W, kg* m2 / s3));
static_assert(verify(isq::radiant_power, scalar, W, kg* m2 / s3));
static_assert(verify(isq::spectral_radiant_flux, scalar, W / nm, kg* m / s3));
static_assert(verify(isq::spectral_radiant_power, scalar, W / nm, kg* m / s3));
static_assert(verify(isq::radiant_intensity, scalar, W / sr, kg* m2 / s3 / sr));
static_assert(verify(isq::spectral_radiant_intensity, scalar, W / (sr * nm), kg* m / s3 / sr));
static_assert(verify(isq::radiance, scalar, W / (sr * m2), kg / s3 / sr));
static_assert(verify(isq::spectral_radiance, scalar, W / (sr * m2 * nm), kg / m / s3 / sr));
static_assert(verify(isq::irradiance, scalar, W / m2, kg / s3));
static_assert(verify(isq::spectral_irradiance, scalar, W / (m2 * nm), kg / m / s3));
static_assert(verify(isq::radiant_exitance, scalar, W / m2, kg / s3));
static_assert(verify(isq::spectral_radiant_exitance, scalar, W / (m2 * nm), kg / m / s3));
static_assert(verify(isq::radiant_exposure, scalar, J / m2, kg / s2));
static_assert(verify(isq::spectral_radiant_exposure, scalar, J / (m2 * nm), kg / m / s2));
static_assert(verify(isq::speed_of_light_in_a_medium, real_scalar, m / s));
static_assert(verify(isq::refractive_index, real_scalar, one));
static_assert(verify(isq::radiant_energy, real_scalar, J, kg* m2 / s2));
static_assert(verify(isq::spectral_radiant_energy, real_scalar, J / nm, kg* m / s2));
static_assert(verify(isq::radiant_energy_density, real_scalar, J / m3, kg / m / s2));
static_assert(verify(isq::spectral_radiant_energy_density_in_terms_of_wavelength, real_scalar, J / (m3 * nm),
kg / m2 / s2));
static_assert(verify(isq::spectral_radiant_energy_density_in_terms_of_wavenumber, real_scalar, J / m2, kg / s2));
static_assert(verify(isq::radiant_flux, real_scalar, W, kg* m2 / s3));
static_assert(verify(isq::radiant_power, real_scalar, W, kg* m2 / s3));
static_assert(verify(isq::spectral_radiant_flux, real_scalar, W / nm, kg* m / s3));
static_assert(verify(isq::spectral_radiant_power, real_scalar, W / nm, kg* m / s3));
static_assert(verify(isq::radiant_intensity, real_scalar, W / sr, kg* m2 / s3 / sr));
static_assert(verify(isq::spectral_radiant_intensity, real_scalar, W / (sr * nm), kg* m / s3 / sr));
static_assert(verify(isq::radiance, real_scalar, W / (sr * m2), kg / s3 / sr));
static_assert(verify(isq::spectral_radiance, real_scalar, W / (sr * m2 * nm), kg / m / s3 / sr));
static_assert(verify(isq::irradiance, real_scalar, W / m2, kg / s3));
static_assert(verify(isq::spectral_irradiance, real_scalar, W / (m2 * nm), kg / m / s3));
static_assert(verify(isq::radiant_exitance, real_scalar, W / m2, kg / s3));
static_assert(verify(isq::spectral_radiant_exitance, real_scalar, W / (m2 * nm), kg / m / s3));
static_assert(verify(isq::radiant_exposure, real_scalar, J / m2, kg / s2));
static_assert(verify(isq::spectral_radiant_exposure, real_scalar, J / (m2 * nm), kg / m / s2));
// atomic and nuclear physics
static_assert(verify(isq::activity, scalar, Bq, one / s));
static_assert(verify(isq::absorbed_dose, scalar, Gy, J / kg, m2 / s2));
static_assert(verify(isq::quality_factor, scalar, one));
static_assert(verify(isq::dose_equivalent, scalar, Sv, J / kg, m2 / s2));
static_assert(verify(isq::activity, real_scalar, Bq, one / s));
static_assert(verify(isq::absorbed_dose, real_scalar, Gy, J / kg, m2 / s2));
static_assert(verify(isq::quality_factor, real_scalar, one));
static_assert(verify(isq::dose_equivalent, real_scalar, Sv, J / kg, m2 / s2));
// information science and technology
static_assert(verify(isq::traffic_intensity, scalar, E));
static_assert(verify(isq::traffic_offered_intensity, scalar, E));
static_assert(verify(isq::traffic_carried_intensity, scalar, E));
static_assert(verify(isq::traffic_load, scalar, E));
static_assert(verify(isq::mean_queue_length, scalar, one));
static_assert(verify(isq::loss_probability, scalar, one));
static_assert(verify(isq::waiting_probability, scalar, one));
static_assert(verify(isq::call_intensity, scalar, one / s));
static_assert(verify(isq::calling_rate, scalar, one / s));
static_assert(verify(isq::completed_call_intensity, scalar, one / s));
static_assert(verify(isq::storage_capacity, scalar, one, bit, o, B));
static_assert(verify(isq::storage_size, scalar, one, bit, o, B));
static_assert(verify(isq::equivalent_binary_storage_capacity, scalar, one, bit));
static_assert(verify(isq::transfer_rate, scalar, one / s, o / s, B / s));
static_assert(verify(isq::period_of_data_elements, scalar, s));
static_assert(verify(isq::binary_digit_rate, scalar, one / s, bit / s));
static_assert(verify(isq::bit_rate, scalar, one / s, bit / s));
static_assert(verify(isq::period_of_binary_digits, scalar, s));
static_assert(verify(isq::bit_period, scalar, s));
static_assert(verify(isq::equivalent_binary_digit_rate, scalar, one / s, bit / s));
static_assert(verify(isq::equivalent_bit_rate, scalar, one / s, bit / s));
static_assert(verify(isq::modulation_rate, scalar, one / s, Bd));
static_assert(verify(isq::line_digit_rate, scalar, one / s, Bd));
static_assert(verify(isq::quantizing_distortion_power, scalar, W));
static_assert(verify(isq::carrier_power, scalar, W));
static_assert(verify(isq::signal_energy_per_binary_digit, scalar, J));
static_assert(verify(isq::error_probability, scalar, one));
static_assert(verify(isq::Hamming_distance, scalar, one));
static_assert(verify(isq::clock_frequency, scalar, Hz));
static_assert(verify(isq::clock_rate, scalar, Hz));
static_assert(verify(isq::decision_content, scalar, one));
static_assert(verify(isq::traffic_intensity, real_scalar, E));
static_assert(verify(isq::traffic_offered_intensity, real_scalar, E));
static_assert(verify(isq::traffic_carried_intensity, real_scalar, E));
static_assert(verify(isq::traffic_load, real_scalar, E));
static_assert(verify(isq::mean_queue_length, real_scalar, one));
static_assert(verify(isq::loss_probability, real_scalar, one));
static_assert(verify(isq::waiting_probability, real_scalar, one));
static_assert(verify(isq::call_intensity, real_scalar, one / s));
static_assert(verify(isq::calling_rate, real_scalar, one / s));
static_assert(verify(isq::completed_call_intensity, real_scalar, one / s));
static_assert(verify(isq::storage_capacity, real_scalar, one, bit, o, B));
static_assert(verify(isq::storage_size, real_scalar, one, bit, o, B));
static_assert(verify(isq::equivalent_binary_storage_capacity, real_scalar, one, bit));
static_assert(verify(isq::transfer_rate, real_scalar, one / s, o / s, B / s));
static_assert(verify(isq::period_of_data_elements, real_scalar, s));
static_assert(verify(isq::binary_digit_rate, real_scalar, one / s, bit / s));
static_assert(verify(isq::bit_rate, real_scalar, one / s, bit / s));
static_assert(verify(isq::period_of_binary_digits, real_scalar, s));
static_assert(verify(isq::bit_period, real_scalar, s));
static_assert(verify(isq::equivalent_binary_digit_rate, real_scalar, one / s, bit / s));
static_assert(verify(isq::equivalent_bit_rate, real_scalar, one / s, bit / s));
static_assert(verify(isq::modulation_rate, real_scalar, one / s, Bd));
static_assert(verify(isq::line_digit_rate, real_scalar, one / s, Bd));
static_assert(verify(isq::quantizing_distortion_power, real_scalar, W));
static_assert(verify(isq::carrier_power, real_scalar, W));
static_assert(verify(isq::signal_energy_per_binary_digit, real_scalar, J));
static_assert(verify(isq::error_probability, real_scalar, one));
static_assert(verify(isq::Hamming_distance, real_scalar, one));
static_assert(verify(isq::clock_frequency, real_scalar, Hz));
static_assert(verify(isq::clock_rate, real_scalar, Hz));
static_assert(verify(isq::decision_content, real_scalar, one));
} // namespace

20
test/static/quantity_spec_test.cpp
View File

@ -86,11 +86,11 @@ QUANTITY_SPEC_(mass_density, mass / volume);
QUANTITY_SPEC_(force, mass * acceleration);
QUANTITY_SPEC_(weight, force, mass * acceleration_of_free_fall);
QUANTITY_SPEC_(moment_of_force, position_vector* force);
QUANTITY_SPEC_(torque, moment_of_force, quantity_character::scalar);
QUANTITY_SPEC_(pressure, force / area, quantity_character::scalar);
QUANTITY_SPEC_(torque, moment_of_force, quantity_character::real_scalar);
QUANTITY_SPEC_(pressure, force / area, quantity_character::real_scalar);
QUANTITY_SPEC_(stress, pressure, quantity_character::tensor);
QUANTITY_SPEC_(strain, dimensionless, quantity_character::tensor);
QUANTITY_SPEC_(power, force* velocity, quantity_character::scalar);
QUANTITY_SPEC_(power, force* velocity, quantity_character::real_scalar);
QUANTITY_SPEC_(efficiency, power / power);
QUANTITY_SPEC_(energy, mass * pow<2>(length) / pow<2>(time));
QUANTITY_SPEC_(mechanical_energy, energy);
@ -100,14 +100,14 @@ QUANTITY_SPEC_(kinetic_energy, mechanical_energy, mass* pow<2>(speed));
QUANTITY_SPEC_(electric_current, dim_electric_current);
QUANTITY_SPEC_(electric_charge, electric_current* time);
QUANTITY_SPEC_(electric_field_strength, force / electric_charge); // vector
QUANTITY_SPEC_(electric_potential, electric_field_strength* length, quantity_character::scalar);
QUANTITY_SPEC_(electric_potential, electric_field_strength* length, quantity_character::real_scalar);
QUANTITY_SPEC_(voltage, electric_potential);
QUANTITY_SPEC_(electromagnetism_power, power, voltage* electric_current);
QUANTITY_SPEC_(electric_current_phasor, electric_current, quantity_character::complex);
QUANTITY_SPEC_(voltage_phasor, voltage, quantity_character::complex);
QUANTITY_SPEC_(electric_current_phasor, electric_current, quantity_character::complex_scalar);
QUANTITY_SPEC_(voltage_phasor, voltage, quantity_character::complex_scalar);
QUANTITY_SPEC_(active_power, power, inverse(period_duration) * (electromagnetism_power * time));
QUANTITY_SPEC_(complex_power, voltage_phasor* electric_current_phasor); // separate kind
QUANTITY_SPEC_(apparent_power, complex_power, quantity_character::scalar);
QUANTITY_SPEC_(apparent_power, complex_power, quantity_character::real_scalar);
// clang-format on
@ -1012,12 +1012,6 @@ static_assert(convertible(kind_of<dimensionless / time>, solid_angular_measure_r
static_assert(convertible(kind_of<dimensionless / time>, kind_of<angular_measure_rate>) == yes);
static_assert(convertible(kind_of<dimensionless / time>, kind_of<solid_angular_measure_rate>) == yes);
// quantity character checks
static_assert((displacement / time).character == quantity_character::vector);
static_assert((position_vector / position_vector * time).character == quantity_character::scalar);
static_assert((velocity / acceleration).character == quantity_character::scalar);
// get_common_quantity_spec
static_assert(get_common_quantity_spec(length, length) == length);
static_assert(get_common_quantity_spec(kind_of<length>, kind_of<length>) == kind_of<length>);

1
test/static/quantity_test.cpp
View File

@ -30,7 +30,6 @@
#include <mp-units/systems/si.h>
#if MP_UNITS_HOSTED
#include <mp-units/cartesian_vector.h>
#include <mp-units/complex.h>
#include <mp-units/math.h>
#endif
#ifdef MP_UNITS_IMPORT_STD