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

docs/users_guide/framework_basics/character_of_a_quantity.md

@@ -126,19 +126,19 @@ character override is needed):
 === "C++23"
 
     ```cpp
-    inline constexpr struct velocity final : quantity_spec<speed, position_vector / duration> {} velocity;
+    inline constexpr struct velocity final : quantity_spec<speed, displacement / duration> {} velocity;
     ```
 
 === "C++20"
 
     ```cpp
-    inline constexpr struct velocity final : quantity_spec<velocity, speed, position_vector / duration> {} velocity;
+    inline constexpr struct velocity final : quantity_spec<velocity, speed, displacement / duration> {} velocity;
     ```
 
 === "Portable"
 
     ```cpp
-    QUANTITY_SPEC(velocity, speed, position_vector / duration);
+    QUANTITY_SPEC(velocity, speed, displacement / duration);
     ```
 
 

example/kalman_filter/kalman_filter-example_2.cpp

@@ -61,7 +61,7 @@ void print(auto iteration, QuantityPoint auto measured, const kalman::SystemStat
 int main()
 {
   using namespace mp_units::si::unit_symbols;
-  using qp = quantity_point<isq::position_vector[m]>;
+  using qp = quantity_point<isq::displacement[m]>;
   using state = kalman::system_state<qp, quantity_point<isq::velocity[m / s]>>;
 
   const quantity interval = isq::duration(5 * s);

example/kalman_filter/kalman_filter-example_3.cpp

@@ -61,7 +61,7 @@ void print(auto iteration, QuantityPoint auto measured, const kalman::SystemStat
 int main()
 {
   using namespace mp_units::si::unit_symbols;
-  using qp = quantity_point<isq::position_vector[m]>;
+  using qp = quantity_point<isq::displacement[m]>;
   using state = kalman::system_state<qp, quantity_point<isq::velocity[m / s]>>;
 
   const quantity interval = isq::duration(5 * s);

example/kalman_filter/kalman_filter-example_4.cpp

@@ -62,7 +62,7 @@ void print(auto iteration, QuantityPoint auto measured, const kalman::SystemStat
 int main()
 {
   using namespace mp_units::si::unit_symbols;
-  using qp = quantity_point<isq::position_vector[m]>;
+  using qp = quantity_point<isq::displacement[m]>;
   using state =
     kalman::system_state<qp, quantity_point<isq::velocity[m / s]>, quantity_point<isq::acceleration[m / s2]>>;
 

src/core/include/mp-units/framework/quantity_spec.h

@@ -280,7 +280,7 @@ struct quantity_spec<Self, Dim, Args...> : detail::quantity_spec_interface<Self>
  * @code{.cpp}
  * inline constexpr struct area final : quantity_spec<pow<2>(length)> {} area;
  * inline constexpr struct volume final : quantity_spec<pow<3>(length)> {} volume;
- * inline constexpr struct velocity final : quantity_spec<position_vector / duration> {} velocity;
+ * inline constexpr struct velocity final : quantity_spec<displacement / duration> {} velocity;
  * inline constexpr struct speed final : quantity_spec<length / time> {} speed;
  * inline constexpr struct force final : quantity_spec<mass * acceleration, quantity_character::vector> {} force;
  * inline constexpr struct power final : quantity_spec<force * velocity, quantity_character::scalar> {} power;
@@ -336,7 +336,7 @@ struct propagate_equation<Q, true> {
  * inline constexpr struct width final : quantity_spec<length> {} width;
  * inline constexpr struct height final : quantity_spec<length> {} height;
  * inline constexpr struct diameter final : quantity_spec<width> {} diameter;
- * inline constexpr struct position_vector final : quantity_spec<length, quantity_character::vector> {} position_vector;
+ * inline constexpr struct displacement final : quantity_spec<length, quantity_character::vector> {} displacement;
  * @endcode
  *
  * @note A common convention in this library is to assign the same name for a type and an object of this type.
@@ -394,7 +394,7 @@ struct quantity_spec<Self, QS, Args...> : detail::propagate_equation<QS>, detail
  *
  * @code{.cpp}
  * inline constexpr struct angular_measure final : quantity_spec<dimensionless, arc_length / radius, is_kind> {} angular_measure;
- * inline constexpr struct velocity final : quantity_spec<speed, position_vector / duration> {} velocity;
+ * inline constexpr struct velocity final : quantity_spec<speed, displacement / duration> {} velocity;
  * inline constexpr struct weight final : quantity_spec<force, mass * acceleration_of_free_fall> {} weight;
  * inline constexpr struct kinetic_energy final : quantity_spec<mechanical_energy, mass * pow<2>(speed)> {} kinetic_energy;
  * @endcode
@@ -470,7 +470,7 @@ struct derived_quantity_spec_impl :
  * auto frequency = inverse(period_duration);
  * auto area = pow<2>(length);
  * auto speed = distance / duration;
- * auto velocity = position_vector / duration;
+ * auto velocity = displacement / duration;
  * auto acceleration = velocity / duration;
  * @endcode
  *
@@ -480,7 +480,7 @@ struct derived_quantity_spec_impl :
  * - the dimension type of `area` is `derived_dimension<power<dim_length, 2>>`
  * - the type of `speed` is `derived_quantity_spec<distance, per<duration>>`
  * - the dimension type of `speed` is `derived_dimension<dim_length, per<dim_time>>`
- * - the type of `velocity` is `derived_quantity_spec<position_vector, per<duration>>`
+ * - the type of `velocity` is `derived_quantity_spec<displacement, per<duration>>`
  * - the dimension type of `velocity` is `derived_dimension<dim_length, per<dim_time>>`
  * - the type of `acceleration` is `derived_quantity_spec<velocity, per<duration>>`
  * - the dimension type of `acceleration` is `derived_dimension<dim_length, per<power<dim_time, 2>>>`

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

@@ -50,10 +50,10 @@ QUANTITY_SPEC(volume, pow<3>(length));
 QUANTITY_SPEC(rotational_displacement, angular_measure, path_length / radius);
 inline constexpr auto angular_displacement = rotational_displacement;
 QUANTITY_SPEC(phase_angle, angular_measure);
-QUANTITY_SPEC(speed, length / time);                         // differs from ISO 80000
+QUANTITY_SPEC(speed, length / time);                      // differs from ISO 80000
-QUANTITY_SPEC(velocity, speed, position_vector / duration);  // vector  // differs from ISO 80000
+QUANTITY_SPEC(velocity, speed, displacement / duration);  // vector  // differs from ISO 80000
-QUANTITY_SPEC(acceleration, velocity / duration);            // vector
+QUANTITY_SPEC(acceleration, velocity / duration);         // vector
-QUANTITY_SPEC(acceleration_of_free_fall, acceleration);      // not in ISO 80000
+QUANTITY_SPEC(acceleration_of_free_fall, acceleration);   // not in ISO 80000
 QUANTITY_SPEC(angular_velocity, angular_displacement / duration, quantity_character::vector);
 QUANTITY_SPEC(angular_acceleration, angular_velocity / duration);
 QUANTITY_SPEC(time_constant, duration);

test/runtime/linear_algebra_test.cpp

@@ -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) ==
+      CHECK(vector<quantity<isq::displacement[m], int>>(v) ==
-            vector<quantity<isq::position_vector[m], int>>{3000 * m, 2000 * m, 1000 * m});
+            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};
+      const vector<quantity<isq::displacement[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});
+      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};
+      const vector<quantity<isq::displacement[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});
+      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});

test/static/quantity_spec_test.cpp

@@ -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(displacement / time / time != acceleration);
-static_assert(position_vector / (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(displacement / time, speed) == yes);
-static_assert(convertible_impl(position_vector / time, velocity) == 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(displacement / 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(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);
 

test/static/quantity_test.cpp

@@ -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<isq::speed[m / s]>, isq::displacement / isq::duration>);
-static_assert(QuantityOf<quantity<m / s>, isq::position_vector / isq::duration>);
+static_assert(QuantityOf<quantity<m / s>, isq::displacement / isq::duration>);
-static_assert(QuantityOf<quantity<kind_of<isq::speed>[m / s]>, isq::position_vector / 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::position_vector / 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