test: ISQ quantities specification tests added

src/systems/isq/include/units/isq/base_quantities.h

@@ -24,6 +24,7 @@
 
 #include <units/dimension.h>
 #include <units/quantity_spec.h>
+#include <units/reference.h>
 
 namespace units::isq {
 

src/systems/isq/include/units/isq/mechanics.h

@@ -22,13 +22,12 @@
 
 #pragma once
 
-#include <units/dimension.h>
 #include <units/isq/base_quantities.h>
 #include <units/isq/space_and_time.h>
+#include <units/quantity_spec.h>
 
 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);

src/systems/isq/include/units/isq/space_and_time.h

@@ -22,12 +22,11 @@
 
 #pragma once
 
-#include <units/dimension.h>
 #include <units/isq/base_quantities.h>
+#include <units/quantity_spec.h>
 
 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<ratio{1, 2}> * diameter);
+// QUANTITY_SPEC(radius, mag<ratio{1, 2}> * 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

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<metre>;
 inline constexpr auto m3 = cubic<metre>;
+inline constexpr auto m4 = pow<4>(metre);
 inline constexpr auto s2 = square<second>;
 inline constexpr auto s3 = cubic<second>;
 

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

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 <units/isq/isq.h>
+#include <units/si/unit_symbols.h>
+
+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