mockingbirdnest · Dec 29, 2019 · Dec 29, 2019
Showing with 15 additions and 15 deletions.

+1 −1 geometry/symmetric_bilinear_form.hpp

+1 −1 geometry/symmetric_bilinear_form_body.hpp

+6 −6 geometry/symmetric_bilinear_form_test.cpp

+5 −5 physics/inertia_tensor.hpp

+2 −2 physics/inertia_tensor_body.hpp
diff --git a/geometry/symmetric_bilinear_form.hpp b/geometry/symmetric_bilinear_form.hpp
@@ -49,7 +49,7 @@ class SymmetricBilinearForm {
   template<typename Eigenframe>
   struct Eigensystem {
     SymmetricBilinearForm<Scalar, Eigenframe> form;
-    Rotation<Frame, Eigenframe> rotation;
+    Rotation<Eigenframe, Frame> rotation;
   };
 
   // Computes a form equivalent to the current one but diagonalized with

diff --git a/geometry/symmetric_bilinear_form_body.hpp b/geometry/symmetric_bilinear_form_body.hpp
@@ -125,7 +125,7 @@ SymmetricBilinearForm<Scalar, Frame>::Diagonalize() const {
   auto const v₀ = Vector<double, Frame>(PickEigenvector(m₀));
   auto const v₁ = Vector<double, Frame>(PickEigenvector(m₁));
 
-  Rotation<Frame, Eigenframe> const rotation{v₀, v₁, Wedge(v₀, v₁)};
+  Rotation<Eigenframe, Frame> const rotation{v₀, v₁, Wedge(v₀, v₁)};
   return {form, rotation};
 }
 

diff --git a/geometry/symmetric_bilinear_form_test.cpp b/geometry/symmetric_bilinear_form_test.cpp
@@ -264,15 +264,15 @@ TEST_F(SymmetricBilinearFormTest, Diagonalize) {
     Vector<double, World> const w₀({ 0, 1, 0});
     Vector<double, World> const w₁({-1, 0, 0});
     Vector<double, World> const w₂({ 0, 0, 1});
-    EXPECT_THAT(f_eigensystem.rotation(w₀),
+    EXPECT_THAT(f_eigensystem.rotation.Inverse()(w₀),
                 Componentwise(AlmostEquals(1, 0),
                               VanishesBefore(1, 1),
                               VanishesBefore(1, 0)));
-    EXPECT_THAT(f_eigensystem.rotation(w₁),
+    EXPECT_THAT(f_eigensystem.rotation.Inverse()(w₁),
                 Componentwise(VanishesBefore(1, 2),
                               AlmostEquals(1, 0),
                               VanishesBefore(1, 0)));
-    EXPECT_THAT(f_eigensystem.rotation(w₂),
+    EXPECT_THAT(f_eigensystem.rotation.Inverse()(w₂),
                 Componentwise(VanishesBefore(1, 0),
                               VanishesBefore(1, 0),
                               AlmostEquals(1, 0)));
@@ -305,15 +305,15 @@ TEST_F(SymmetricBilinearFormTest, Diagonalize) {
     Vector<double, World> const w₂({0.50207513078793658603,
                                     0.52940122795673242036,
                                     0.68385298338325629274});
-    EXPECT_THAT(f_eigensystem.rotation(w₀),
+    EXPECT_THAT(f_eigensystem.rotation.Inverse()(w₀),
                 Componentwise(AlmostEquals(1, 0),
                               VanishesBefore(1, 0),
                               VanishesBefore(1, 0)));
-    EXPECT_THAT(f_eigensystem.rotation(w₁),
+    EXPECT_THAT(f_eigensystem.rotation.Inverse()(w₁),
                 Componentwise(VanishesBefore(1, 0),
                               AlmostEquals(1, 0),
                               VanishesBefore(1, 0)));
-    EXPECT_THAT(f_eigensystem.rotation(w₂),
+    EXPECT_THAT(f_eigensystem.rotation.Inverse()(w₂),
                 Componentwise(VanishesBefore(1, 1),
                               VanishesBefore(1, 2),
                               AlmostEquals(1, 0)));

diff --git a/physics/inertia_tensor.hpp b/physics/inertia_tensor.hpp
@@ -58,16 +58,16 @@ class InertiaTensor {
   InertiaTensor<ToFrame> Transform(
       RigidTransformation<Frame, ToFrame> const& transformation) const;
 
+  // A factory that creates an inertia tensor for a solid sphere of water having
+  // the given mass.  Useful e.g. for save compatibility.
+  static InertiaTensor<Frame> MakeWaterSphereInertiaTensor(Mass const& mass);
+
   template<typename PrincipalAxesFrame>
   struct PrincipalAxes {
     R3Element<MomentOfInertia> moments_of_inertia;
-    Rotation<Frame, PrincipalAxesFrame> rotation;
+    Rotation<PrincipalAxesFrame, Frame> rotation;
   };
 
-  // A factory that creates an inertia tensor for a solid sphere of water having
-  // the given mass.  Useful e.g. for save compatibility.
-  static InertiaTensor<Frame> MakeWaterSphereInertiaTensor(Mass const& mass);
-
   // Diagonalization is possible in any frame, but it's mostly used in a frame
   // centred at the centre of mass.
   template<typename PrincipalAxesFrame>

diff --git a/physics/inertia_tensor_body.hpp b/physics/inertia_tensor_body.hpp
@@ -100,10 +100,10 @@ InertiaTensor<Frame>::Diagonalize() const {
 
   auto const y = Bivector<double, IntermediateFrame>({0, 1, 0});
   auto const z = Bivector<double, IntermediateFrame>({0, 0, 1});
-  Rotation<IntermediateFrame, PrincipalAxesFrame> const swap_x_and_z(
+  Rotation<PrincipalAxesFrame, IntermediateFrame> const swap_x_and_z(
       z, y, Commutator(z, y));
 
-  return {moments_of_inertia, swap_x_and_z * eigensystem.rotation};
+  return {moments_of_inertia, eigensystem.rotation * swap_x_and_z};
 }
 
 template<typename Frame>