From 5152db638238016600a0d11c20473c029e768276 Mon Sep 17 00:00:00 2001 From: Mateusz Pusz Date: Sat, 17 Dec 2022 16:18:14 +0100 Subject: [PATCH] test: ISQ quantities specification tests added --- .../isq/include/units/isq/base_quantities.h | 1 + src/systems/isq/include/units/isq/mechanics.h | 17 +- .../isq/include/units/isq/space_and_time.h | 17 +- .../si/include/units/si/unit_symbols.h | 1 + test/unit_test/static/CMakeLists.txt | 1 + test/unit_test/static/isq_test.cpp | 164 ++++++++++++++++++ 6 files changed, 184 insertions(+), 17 deletions(-) create mode 100644 test/unit_test/static/isq_test.cpp diff --git a/src/systems/isq/include/units/isq/base_quantities.h b/src/systems/isq/include/units/isq/base_quantities.h index f7996379..420182f0 100644 --- a/src/systems/isq/include/units/isq/base_quantities.h +++ b/src/systems/isq/include/units/isq/base_quantities.h @@ -24,6 +24,7 @@ #include #include +#include namespace units::isq { diff --git a/src/systems/isq/include/units/isq/mechanics.h b/src/systems/isq/include/units/isq/mechanics.h index 018eeb65..508a4b74 100644 --- a/src/systems/isq/include/units/isq/mechanics.h +++ b/src/systems/isq/include/units/isq/mechanics.h @@ -22,13 +22,12 @@ #pragma once -#include #include #include +#include namespace units::isq { -// inline constexpr struct mass : base_dimension<"M"> {} mass; QUANTITY_SPEC(mass_density, mass / volume); inline constexpr auto density = mass_density; QUANTITY_SPEC(specific_volume, 1 / mass_density); @@ -38,7 +37,7 @@ QUANTITY_SPEC(surface_mass_density, mass / area); inline constexpr auto surface_density = surface_mass_density; QUANTITY_SPEC(linear_mass_density, mass / length); inline constexpr auto linear_density = linear_mass_density; -QUANTITY_SPEC(momentum, mass* velocity); +QUANTITY_SPEC(momentum, mass* velocity); // TODO vector? QUANTITY_SPEC(force, mass* acceleration); // vector // TODO what is a correct equation here? QUANTITY_SPEC(weight, force); // vector // TODO g? QUANTITY_SPEC(static_friction_force, force); // vector @@ -62,7 +61,7 @@ QUANTITY_SPEC(normal_stress, pressure, quantity_character::scalar); QUANTITY_SPEC(shear_stress, pressure, quantity_character::scalar); QUANTITY_SPEC(strain, dimensionless, quantity_character::tensor); QUANTITY_SPEC(relative_linear_strain, length / length); -QUANTITY_SPEC(shear_strain, displacement / thickness); +QUANTITY_SPEC(shear_strain, displacement / thickness); // TODO scalar or vector? QUANTITY_SPEC(relative_volume_strain, volume / volume); QUANTITY_SPEC(Poisson_number, width / length); QUANTITY_SPEC(modulus_of_elasticity, normal_stress / relative_linear_strain); @@ -83,16 +82,18 @@ inline constexpr auto coefficient_of_static_friction = static_friction_coefficie QUANTITY_SPEC(kinetic_friction_factor, kinetic_friction_force / force, quantity_character::scalar); inline constexpr auto dynamic_friction_factor = kinetic_friction_factor; QUANTITY_SPEC(rolling_resistance_factor, force / force, quantity_character::scalar); -// QUANTITY_SPEC(drag_coefficient, mag<2>* drag_force / (mass_density * pow<2>(speed) * area)); -// inline constexpr auto drag_factor = drag_coefficient; +QUANTITY_SPEC(drag_coefficient, drag_force / (mass_density * pow<2>(speed) * area)); // TODO scalar or vector? +// QUANTITY_SPEC(drag_coefficient, mag<2>* drag_force / (mass_density * pow<2>(speed) * area)); // TODO should we +// support that? +inline constexpr auto drag_factor = drag_coefficient; QUANTITY_SPEC(dynamic_viscosity, shear_stress* length / velocity); QUANTITY_SPEC(kinematic_viscosity, dynamic_viscosity / mass_density); QUANTITY_SPEC(surface_tension, force / length, quantity_character::scalar); // TODO what is a correct equation here? QUANTITY_SPEC(power, force* velocity, quantity_character::scalar); // QUANTITY_SPEC(energy, force* length); -QUANTITY_SPEC(potential_energy, mass* acceleration* height); // TODO what is a correct equation here? +QUANTITY_SPEC(potential_energy, mass* pow<2>(length) / pow<2>(time)); // TODO what is a correct equation here? QUANTITY_SPEC(kinetic_energy, mass* pow<2>(speed)); -// QUANTITY_SPEC(kinetic_energy, mag<1, 2>* mass* pow<2>(speed)); +// QUANTITY_SPEC(kinetic_energy, mag<1, 2>* mass* pow<2>(speed)); // TODO should we support that? // TODO how to implement that? // QUANTITY_SPEC(mechanical_energy, potential_energy + kinetic_energy); QUANTITY_SPEC(mechanical_energy, potential_energy); diff --git a/src/systems/isq/include/units/isq/space_and_time.h b/src/systems/isq/include/units/isq/space_and_time.h index 6dafb6b3..40133efc 100644 --- a/src/systems/isq/include/units/isq/space_and_time.h +++ b/src/systems/isq/include/units/isq/space_and_time.h @@ -22,12 +22,11 @@ #pragma once -#include #include +#include namespace units::isq { -// clang-format off QUANTITY_SPEC(width, length); inline constexpr auto breadth = width; QUANTITY_SPEC(height, length); @@ -35,7 +34,7 @@ inline constexpr auto depth = height; inline constexpr auto altitude = height; QUANTITY_SPEC(thickness, width); QUANTITY_SPEC(diameter, width); -// QUANTITY_SPEC(radius, mag * diameter); +// QUANTITY_SPEC(radius, mag * diameter); // TODO should we support that? QUANTITY_SPEC(radius, diameter); QUANTITY_SPEC(path_length, length); inline constexpr auto arc_length = path_length; @@ -51,11 +50,11 @@ QUANTITY_SPEC(angular_measure, arc_length / radius); QUANTITY_SPEC(rotational_displacement, path_length / radius); inline constexpr auto angular_displacement = rotational_displacement; QUANTITY_SPEC(phase_angle, angular_measure); -QUANTITY_SPEC(solid_angular_measure, angular_measure * angular_measure); +QUANTITY_SPEC(solid_angular_measure, angular_measure* angular_measure); inline constexpr auto duration = time; QUANTITY_SPEC(velocity, position_vector / duration); // vector -QUANTITY_SPEC(speed, distance / duration); // TODO length, path_length? -QUANTITY_SPEC(acceleration, velocity / duration); // vector +QUANTITY_SPEC(speed, distance / duration); // TODO length, path_length? +QUANTITY_SPEC(acceleration, velocity / duration); // vector QUANTITY_SPEC(angular_velocity, angular_displacement / duration, quantity_character::vector); QUANTITY_SPEC(angular_acceleration, angular_velocity / duration); QUANTITY_SPEC(period_duration, duration); @@ -76,11 +75,11 @@ inline constexpr auto phase_speed = phase_velocity; QUANTITY_SPEC(group_velocity, angular_frequency / angular_repetency); inline constexpr auto group_speed = group_velocity; QUANTITY_SPEC(damping_coefficient, 1 / time_constant); -QUANTITY_SPEC(logarithmic_decrement, damping_coefficient * period_duration); +QUANTITY_SPEC(logarithmic_decrement, damping_coefficient* period_duration); QUANTITY_SPEC(attenuation, 1 / distance); inline constexpr auto extinction = attenuation; QUANTITY_SPEC(phase_coefficient, phase_angle / path_length); -QUANTITY_SPEC(propagation_coefficient, 1 / length); // γ = α + iβ where α denotes attenuation and β the phase coefficient of a plane wave -// clang-format on +QUANTITY_SPEC(propagation_coefficient, 1 / length); // γ = α + iβ where α denotes attenuation + // and β the phase coefficient of a plane wave } // namespace units::isq diff --git a/src/systems/si/include/units/si/unit_symbols.h b/src/systems/si/include/units/si/unit_symbols.h index 2b740885..a377ed75 100644 --- a/src/systems/si/include/units/si/unit_symbols.h +++ b/src/systems/si/include/units/si/unit_symbols.h @@ -640,6 +640,7 @@ inline constexpr auto d = day; // commonly used squared and cubic units inline constexpr auto m2 = square; inline constexpr auto m3 = cubic; +inline constexpr auto m4 = pow<4>(metre); inline constexpr auto s2 = square; inline constexpr auto s3 = cubic; diff --git a/test/unit_test/static/CMakeLists.txt b/test/unit_test/static/CMakeLists.txt index 332059e3..9fd18a39 100644 --- a/test/unit_test/static/CMakeLists.txt +++ b/test/unit_test/static/CMakeLists.txt @@ -47,6 +47,7 @@ add_library( # fixed_string_test.cpp # fps_test.cpp # iec80000_test.cpp + isq_test.cpp # kind_test.cpp magnitude_test.cpp # math_test.cpp diff --git a/test/unit_test/static/isq_test.cpp b/test/unit_test/static/isq_test.cpp new file mode 100644 index 00000000..ea71d6c8 --- /dev/null +++ b/test/unit_test/static/isq_test.cpp @@ -0,0 +1,164 @@ +// The MIT License (MIT) +// +// Copyright (c) 2018 Mateusz Pusz +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +#include +#include + +namespace { + +using namespace units; +using namespace units::si::unit_symbols; +using enum units::quantity_character; + +[[nodiscard]] consteval bool verify(QuantitySpec auto q, quantity_character ch, Unit auto... units) +{ + return q.character == ch && (... && requires { q[units]; }); +} + +// 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::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, 1 / 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::velocity, vector, m / s)); +static_assert(verify(isq::speed, scalar, m / s)); +static_assert(verify(isq::acceleration, vector, m / s2)); +static_assert(verify(isq::angular_velocity, vector, rad / s, 1 / s)); +static_assert(verify(isq::angular_acceleration, vector, rad / s2, 1 / 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, 1 / s)); +static_assert(verify(isq::rotational_frequency, scalar, 1 / s)); +static_assert(verify(isq::angular_frequency, scalar, rad / s, 1 / s)); +static_assert(verify(isq::wavelength, scalar, m)); +static_assert(verify(isq::repetency, scalar, 1 / m)); +static_assert(verify(isq::wavenumber, scalar, 1 / m)); +static_assert(verify(isq::wave_vector, vector, 1 / m)); +static_assert(verify(isq::angular_repetency, scalar, 1 / m)); +static_assert(verify(isq::angular_wavenumber, scalar, 1 / m)); +static_assert(verify(isq::phase_velocity, scalar, m / s)); +static_assert(verify(isq::phase_speed, scalar, m / s)); +static_assert(verify(isq::group_velocity, scalar, m / s)); +static_assert(verify(isq::group_speed, scalar, m / s)); +static_assert(verify(isq::damping_coefficient, scalar, 1 / s)); +static_assert(verify(isq::logarithmic_decrement, scalar, one)); +static_assert(verify(isq::attenuation, scalar, 1 / m)); +static_assert(verify(isq::extinction, scalar, 1 / m)); +static_assert(verify(isq::phase_coefficient, scalar, rad / m, 1 / m)); +static_assert(verify(isq::propagation_coefficient, scalar, 1 / 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::moment_of_inertia, tensor, kg* m2)); +static_assert(verify(isq::momentum, vector, kg* m / s)); // TODO vector? +static_assert(verify(isq::force, vector, N, kg* m / s2)); +static_assert(verify(isq::weight, vector, N, kg* m / s2)); +static_assert(verify(isq::static_friction_force, vector, N, kg* m / s2)); +static_assert(verify(isq::static_friction, vector, N, kg* m / s2)); +static_assert(verify(isq::kinetic_friction_force, vector, N, kg* m / s2)); +static_assert(verify(isq::dynamic_friction_force, vector, N, kg* m / s2)); +static_assert(verify(isq::rolling_resistance, vector, N, kg* m / s2)); +static_assert(verify(isq::rolling_drag, vector, N, kg* m / s2)); +static_assert(verify(isq::rolling_friction_force, vector, N, kg* m / s2)); +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::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::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::strain, tensor, one)); +static_assert(verify(isq::relative_linear_strain, scalar, one)); +static_assert(verify(isq::shear_strain, vector, one)); // TODO scalar or vector? +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, 1 / 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, vector, one)); +static_assert(verify(isq::drag_factor, vector, 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::efficiency, 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)); + +} // namespace