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

fix: velocity is now defined in terms of displacement instead of position_vector

Browse Source
This commit is contained in:
Mateusz Pusz
2024-11-06 18:46:01 +01:00
parent 0c692dca8c
commit 6896d8e086
9 changed files with 69 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
test/runtime/linear_algebra_test.cpp
View File

@@ -103,13 +103,13 @@ TEST_CASE("vector quantity", "[la]")
{
SECTION("non-truncating")
{
const auto v = vector<int>{3, 2, 1} * isq::position_vector[km];
const auto v = vector<int>{3, 2, 1} * isq::displacement[km];
CHECK(v.numerical_value_in(m) == vector<int>{3000, 2000, 1000});
}
SECTION("truncating")
{
const auto v = vector<int>{1001, 1002, 1003} * isq::position_vector[m];
const auto v = vector<int>{1001, 1002, 1003} * isq::displacement[m];
CHECK(v.force_numerical_value_in(km) == vector<int>{1, 1, 1});
}
}
@@ -123,7 +123,7 @@ TEST_CASE("vector quantity", "[la]")
SECTION("multiply by scalar value")
{
const auto v = vector<int>{1, 2, 3} * isq::position_vector[m];
const auto v = vector<int>{1, 2, 3} * isq::displacement[m];
SECTION("integral")
{
@@ -140,7 +140,7 @@ TEST_CASE("vector quantity", "[la]")
SECTION("divide by scalar value")
{
const auto v = vector<int>{2, 4, 6} * isq::position_vector[m];
const auto v = vector<int>{2, 4, 6} * isq::displacement[m];
SECTION("integral") { CHECK((v / 2).numerical_value_in(m) == vector<int>{1, 2, 3}); }
SECTION("floating-point") { CHECK((v / 0.5).numerical_value_in(m) == vector<double>{4., 8., 12.}); }
@@ -148,32 +148,32 @@ TEST_CASE("vector quantity", "[la]")
SECTION("add")
{
const auto v = vector<int>{1, 2, 3} * isq::position_vector[m];
const auto v = vector<int>{1, 2, 3} * isq::displacement[m];
SECTION("same unit")
{
const auto u = vector<int>{3, 2, 1} * isq::position_vector[m];
const auto u = vector<int>{3, 2, 1} * isq::displacement[m];
CHECK((v + u).numerical_value_in(m) == vector<int>{4, 4, 4});
}
SECTION("different units")
{
const auto u = vector<int>{3, 2, 1} * isq::position_vector[km];
const auto u = vector<int>{3, 2, 1} * isq::displacement[km];
CHECK((v + u).numerical_value_in(m) == vector<int>{3001, 2002, 1003});
}
}
SECTION("subtract")
{
const auto v = vector<int>{1, 2, 3} * isq::position_vector[m];
const auto v = vector<int>{1, 2, 3} * isq::displacement[m];
SECTION("same unit")
{
const auto u = vector<int>{3, 2, 1} * isq::position_vector[m];
const auto u = vector<int>{3, 2, 1} * isq::displacement[m];
CHECK((v - u).numerical_value_in(m) == vector<int>{-2, 0, 2});
}
SECTION("different units")
{
const auto u = vector<int>{3, 2, 1} * isq::position_vector[km];
const auto u = vector<int>{3, 2, 1} * isq::displacement[km];
CHECK((v - u).numerical_value_in(m) == vector<int>{-2999, -1998, -997});
}
}
@@ -255,7 +255,7 @@ TEST_CASE("vector quantity", "[la]")
SECTION("divide by scalar quantity")
{
const auto pos = vector<int>{30, 20, 10} * isq::position_vector[km];
const auto pos = vector<int>{30, 20, 10} * isq::displacement[km];
SECTION("integral")
{
@@ -292,7 +292,7 @@ TEST_CASE("vector quantity", "[la]")
SECTION("cross product with a vector quantity")
{
const auto r = vector<int>{3, 0, 0} * isq::position_vector[m];
const auto r = vector<int>{3, 0, 0} * isq::displacement[m];
const auto f = vector<int>{0, 10, 0} * isq::force[N];
CHECK(cross_product(r, f) == vector<int>{0, 0, 30} * isq::moment_of_force[N * m]);
@@ -309,10 +309,10 @@ TEST_CASE("vector of quantities", "[la]")
{
SECTION("non-truncating")
{
const vector<quantity<isq::position_vector[km], int>> v = {3 * km, 2 * km, 1 * km};
const vector<quantity<isq::displacement[km], int>> v = {3 * km, 2 * km, 1 * km};
CHECK(vector<quantity<isq::position_vector[m], int>>(v) ==
vector<quantity<isq::position_vector[m], int>>{3000 * m, 2000 * m, 1000 * m});
CHECK(vector<quantity<isq::displacement[m], int>>(v) ==
vector<quantity<isq::displacement[m], int>>{3000 * m, 2000 * m, 1000 * m});
}
// truncating not possible (no way to apply quantity_cast to sub-components of a vector)
@@ -327,11 +327,11 @@ TEST_CASE("vector of quantities", "[la]")
SECTION("multiply by scalar value")
{
const vector<quantity<isq::position_vector[m], int>> v = {1 * m, 2 * m, 3 * m};
const vector<quantity<isq::displacement[m], int>> v = {1 * m, 2 * m, 3 * m};
SECTION("integral")
{
const vector<quantity<isq::position_vector[m], int>> result = {2 * m, 4 * m, 6 * m};
const vector<quantity<isq::displacement[m], int>> result = {2 * m, 4 * m, 6 * m};
SECTION("scalar on LHS") { CHECK(2 * v == result); }
SECTION("scalar on RHS") { CHECK(v * 2 == result); }
@@ -339,7 +339,7 @@ TEST_CASE("vector of quantities", "[la]")
SECTION("floating-point")
{
const vector<quantity<isq::position_vector[m], double>> result = {0.5 * m, 1. * m, 1.5 * m};
const vector<quantity<isq::displacement[m], double>> result = {0.5 * m, 1. * m, 1.5 * m};
SECTION("scalar on LHS") { CHECK(0.5 * v == result); }
SECTION("scalar on RHS") { CHECK(v * 0.5 == result); }
@@ -348,46 +348,46 @@ TEST_CASE("vector of quantities", "[la]")
SECTION("divide by scalar value")
{
const vector<quantity<isq::position_vector[m], int>> v = {2 * m, 4 * m, 6 * m};
const vector<quantity<isq::displacement[m], int>> v = {2 * m, 4 * m, 6 * m};
SECTION("integral") { CHECK(v / 2 == vector<quantity<isq::position_vector[m], int>>{1 * m, 2 * m, 3 * m}); }
SECTION("integral") { CHECK(v / 2 == vector<quantity<isq::displacement[m], int>>{1 * m, 2 * m, 3 * m}); }
SECTION("floating-point")
{
CHECK(v / 0.5 == vector<quantity<isq::position_vector[m], double>>{4. * m, 8. * m, 12. * m});
CHECK(v / 0.5 == vector<quantity<isq::displacement[m], double>>{4. * m, 8. * m, 12. * m});
}
}
SECTION("add")
{
const vector<quantity<isq::position_vector[m], int>> v = {1 * m, 2 * m, 3 * m};
const vector<quantity<isq::displacement[m], int>> v = {1 * m, 2 * m, 3 * m};
SECTION("same unit")
{
const vector<quantity<isq::position_vector[m], int>> u = {3 * m, 2 * m, 1 * m};
const vector<quantity<isq::displacement[m], int>> u = {3 * m, 2 * m, 1 * m};
CHECK(v + u == vector<quantity<isq::position_vector[m], int>>{4 * m, 4 * m, 4 * m});
CHECK(v + u == vector<quantity<isq::displacement[m], int>>{4 * m, 4 * m, 4 * m});
}
SECTION("different units")
{
const vector<quantity<isq::position_vector[km], int>> u = {3 * km, 2 * km, 1 * km};
const vector<quantity<isq::displacement[km], int>> u = {3 * km, 2 * km, 1 * km};
CHECK(v + u == vector<quantity<isq::position_vector[m], int>>{3001 * m, 2002 * m, 1003 * m});
CHECK(v + u == vector<quantity<isq::displacement[m], int>>{3001 * m, 2002 * m, 1003 * m});
}
}
SECTION("subtract")
{
const vector<quantity<isq::position_vector[m], int>> v = {1 * m, 2 * m, 3 * m};
const vector<quantity<isq::displacement[m], int>> v = {1 * m, 2 * m, 3 * m};
SECTION("same unit")
{
const vector<quantity<isq::position_vector[m], int>> u = {3 * m, 2 * m, 1 * m};
CHECK(v - u == vector<quantity<isq::position_vector[m], int>>{-2 * m, 0 * m, 2 * m});
const vector<quantity<isq::displacement[m], int>> u = {3 * m, 2 * m, 1 * m};
CHECK(v - u == vector<quantity<isq::displacement[m], int>>{-2 * m, 0 * m, 2 * m});
}
SECTION("different units")
{
const vector<quantity<isq::position_vector[km], int>> u = {3 * km, 2 * km, 1 * km};
CHECK(v - u == vector<quantity<isq::position_vector[m], int>>{-2999 * m, -1998 * m, -997 * m});
const vector<quantity<isq::displacement[km], int>> u = {3 * km, 2 * km, 1 * km};
CHECK(v - u == vector<quantity<isq::displacement[m], int>>{-2999 * m, -1998 * m, -997 * m});
}
}
@@ -454,7 +454,7 @@ TEST_CASE("vector of quantities", "[la]")
SECTION("divide by scalar quantity")
{
const vector<quantity<isq::position_vector[km], int>> pos = {30 * km, 20 * km, 10 * km};
const vector<quantity<isq::displacement[km], int>> pos = {30 * km, 20 * km, 10 * km};
SECTION("integral")
{
@@ -495,7 +495,7 @@ TEST_CASE("vector of quantities", "[la]")
SECTION("cross product with a vector of quantities")
{
const vector<quantity<isq::position_vector[m], int>> r = {3 * m, 0 * m, 0 * m};
const vector<quantity<isq::displacement[m], int>> r = {3 * m, 0 * m, 0 * m};
const vector<quantity<isq::force[N], int>> f = {0 * N, 10 * N, 0 * N};
CHECK(cross_product(r, f) == vector<quantity<isq::moment_of_force[N * m], int>>{0 * N * m, 0 * N * m, 30 * N * m});

33
test/static/quantity_spec_test.cpp
View File

@@ -56,6 +56,7 @@ inline constexpr auto arc_length = path_length;
QUANTITY_SPEC_(distance, path_length);
QUANTITY_SPEC_(wavelength, length);
QUANTITY_SPEC_(position_vector, length, quantity_character::vector);
QUANTITY_SPEC_(displacement, length, quantity_character::vector);
QUANTITY_SPEC_(period_duration, time);
QUANTITY_SPEC_(rotation, dimensionless);
QUANTITY_SPEC_(repetency, inverse(wavelength));
@@ -68,7 +69,7 @@ QUANTITY_SPEC_(rotational_displacement, angular_measure, path_length / radius);
QUANTITY_SPEC_(phase_angle, angular_measure);
QUANTITY_SPEC_(solid_angular_measure, dimensionless, area / pow<2>(radius), is_kind);
QUANTITY_SPEC_(speed, length / time);
QUANTITY_SPEC_(velocity, speed, position_vector / time);
QUANTITY_SPEC_(velocity, speed, displacement / time);
QUANTITY_SPEC_(special_speed, speed);
QUANTITY_SPEC_(rate_of_climb, speed, height / time);
QUANTITY_SPEC_(special_rate_of_climb, rate_of_climb);
@@ -377,9 +378,9 @@ static_assert(force * length != torque);
static_assert(force * position_vector != energy);
static_assert(force * position_vector != torque);
static_assert(length / time != speed);
static_assert(position_vector / time != speed);
static_assert(displacement / time != speed);
static_assert(length / time != velocity);
static_assert(position_vector / time != velocity);
static_assert(displacement / time != velocity);
static_assert(length * time / period_duration != time);
static_assert(length * height / width != length);
@@ -390,12 +391,12 @@ static_assert(length / speed != time);
static_assert(speed * time != length);
static_assert(length / time / time != acceleration);
static_assert(position_vector / time / time != acceleration);
static_assert(position_vector / (time * time) != acceleration);
static_assert(displacement / time / time != acceleration);
static_assert(displacement / (time * time) != acceleration);
static_assert(velocity / time != acceleration);
static_assert(velocity / acceleration != time);
static_assert(acceleration * time != velocity);
static_assert(acceleration * (time * time) != position_vector);
static_assert(acceleration * (time * time) != displacement);
static_assert(acceleration / speed != frequency);
// get_kind
@@ -471,7 +472,7 @@ static_assert(get_complexity(speed * area / frequency) == 1);
// explode
static_assert(explode<get_complexity(inverse(time))>(frequency).quantity == inverse(period_duration));
static_assert(explode<get_complexity(kind_of<length / time>)>(speed).quantity == length / time);
static_assert(explode<get_complexity(kind_of<length / time>)>(velocity).quantity == position_vector / time);
static_assert(explode<get_complexity(kind_of<length / time>)>(velocity).quantity == displacement / time);
static_assert(explode<get_complexity(dimensionless)>(angular_measure).quantity == arc_length / radius);
static_assert(explode<get_complexity(velocity)>(acceleration * time).quantity == velocity);
static_assert(explode<get_complexity(area)>(area).quantity == area);
@@ -582,8 +583,8 @@ static_assert(convertible_impl(inverse(frequency), time) == yes);
static_assert(convertible_impl(inverse(period_duration), frequency) == yes);
static_assert(convertible_impl(length * length, area) == yes);
static_assert(convertible_impl(length / time, speed) == yes);
static_assert(convertible_impl(position_vector / time, speed) == yes);
static_assert(convertible_impl(position_vector / time, velocity) == yes);
static_assert(convertible_impl(displacement / time, speed) == yes);
static_assert(convertible_impl(displacement / time, velocity) == yes);
static_assert(convertible_impl(height / time, speed) == yes);
static_assert(convertible_impl(height / time, rate_of_climb) == yes);
static_assert(convertible_impl(area / length, length) == yes);
@@ -597,12 +598,12 @@ static_assert(convertible_impl(area * (area / length), volume) == yes);
static_assert(convertible_impl(volume / (length * length), length) == yes);
static_assert(convertible_impl(length / speed, time) == yes);
static_assert(convertible_impl(speed * time, length) == yes);
static_assert(convertible_impl(position_vector / time / time, acceleration) == yes);
static_assert(convertible_impl(position_vector / (time * time), acceleration) == yes);
static_assert(convertible_impl(displacement / time / time, acceleration) == yes);
static_assert(convertible_impl(displacement / (time * time), acceleration) == yes);
static_assert(convertible_impl(velocity / time, acceleration) == yes);
static_assert(convertible_impl(velocity / acceleration, time) == yes);
static_assert(convertible_impl(acceleration * time, velocity) == yes);
static_assert(convertible_impl(acceleration * (time * time), position_vector) == yes);
static_assert(convertible_impl(acceleration * (time * time), displacement) == yes);
static_assert(convertible_impl(mass * pow<2>(length) / pow<2>(time), energy) == yes);
static_assert(convertible_impl(force * length, energy) == yes);
static_assert(convertible_impl(force * position_vector, moment_of_force) == yes);
@@ -648,18 +649,18 @@ static_assert(convertible_impl(distance / speed, time) == yes);
// derived quantities to incompatible type
static_assert(convertible_impl(height / time, velocity) == cast);
static_assert(convertible_impl(position_vector / time, rate_of_climb) == cast);
static_assert(convertible_impl(displacement / time, rate_of_climb) == cast);
// type to compatible derived
static_assert(convertible_impl(distance, speed* time) == yes);
// type to more specialized derived quantity
static_assert(convertible_impl(speed, height / time) == explicit_conversion);
static_assert(convertible_impl(speed, position_vector / time) == explicit_conversion);
static_assert(convertible_impl(speed, displacement / time) == explicit_conversion);
// type to a derived quantity on a different branch
static_assert(convertible_impl(velocity, height / time) == cast);
static_assert(convertible_impl(rate_of_climb, position_vector / time) == cast);
static_assert(convertible_impl(rate_of_climb, displacement / time) == cast);
// derived quantities requiring explosion to a type
static_assert(convertible_impl(acceleration * time, velocity) == yes);
@@ -792,7 +793,7 @@ static_assert(convertible_impl(length / width, dimensionless) == yes);
static_assert(convertible_impl(efficiency, strain) == cast);
// quantity character checks
static_assert((position_vector / time).character == quantity_character::vector);
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);

8
test/static/quantity_test.cpp
View File

@@ -1127,10 +1127,10 @@ static_assert(!QuantityOf<quantity<isq::speed[m / s]>, isq::distance / isq::dura
static_assert(!QuantityOf<quantity<isq::speed[m / s]>, isq::width / isq::duration>);
static_assert(QuantityOf<quantity<m / s>, isq::width / isq::duration>);
static_assert(QuantityOf<quantity<kind_of<isq::speed>[m / s]>, isq::width / isq::duration>);
static_assert(!QuantityOf<quantity<isq::speed[m / s]>, isq::position_vector / isq::duration>);
static_assert(QuantityOf<quantity<m / s>, isq::position_vector / isq::duration>);
static_assert(QuantityOf<quantity<kind_of<isq::speed>[m / s]>, isq::position_vector / isq::duration>);
static_assert(QuantityOf<quantity<isq::velocity[m / s], int>, isq::position_vector / isq::duration>);
static_assert(!QuantityOf<quantity<isq::speed[m / s]>, isq::displacement / isq::duration>);
static_assert(QuantityOf<quantity<m / s>, isq::displacement / isq::duration>);
static_assert(QuantityOf<quantity<kind_of<isq::speed>[m / s]>, isq::displacement / isq::duration>);
static_assert(QuantityOf<quantity<isq::velocity[m / s], int>, isq::displacement / isq::duration>);
static_assert(QuantityOf<decltype(10 * m), isq::height>); // kind of
static_assert(QuantityOf<decltype(10 * kind_of<isq::length>[m]), isq::height>); // kind of