mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2025-08-13 00:54:27 +02:00
Code Issues Packages Projects Releases Wiki Activity

test: ISQ quantities specification tests added

Browse Source
This commit is contained in:
Mateusz Pusz
2022-12-17 16:18:14 +01:00
parent f37ec4c62b
commit 5152db6382
6 changed files with 184 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/systems/isq/include/units/isq/base_quantities.h
View File

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

17
src/systems/isq/include/units/isq/mechanics.h
View File

@@ -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);

9
src/systems/isq/include/units/isq/space_and_time.h
View File

@@ -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;
@@ -80,7 +79,7 @@ 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

1
src/systems/si/include/units/si/unit_symbols.h
View File

@@ -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>;

1
test/unit_test/static/CMakeLists.txt
View File

@@ -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

164
test/unit_test/static/isq_test.cpp Normal file
View File

@@ -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