diff --git a/crates/lox_core/src/bodies.rs b/crates/lox_core/src/bodies.rs
index 5ca895e3..dae76453 100644
--- a/crates/lox_core/src/bodies.rs
+++ b/crates/lox_core/src/bodies.rs
@@ -64,17 +64,9 @@ pub fn gravitational_parameter<T: PointMass>(_: T) -> f64 {
     <T as PointMass>::gravitational_parameter()
 }
 
-pub const N_COEFFICIENTS: usize = 18;
+pub type PolynomialCoefficients = (f64, f64, f64, &'static [f64]);
 
-pub struct PolynomialCoefficients(f64, f64, f64, [f64; N_COEFFICIENTS]);
-
-pub struct NutationPrecessionCoefficients(pub [f64; N_COEFFICIENTS], pub [f64; N_COEFFICIENTS]);
-
-impl Default for NutationPrecessionCoefficients {
-    fn default() -> Self {
-        Self([0.0; N_COEFFICIENTS], [0.0; N_COEFFICIENTS])
-    }
-}
+pub type NutationPrecessionCoefficients = (&'static [f64], &'static [f64]);
 
 pub trait RotationalElements {
     fn nutation_precession_coefficients() -> NutationPrecessionCoefficients;
@@ -85,11 +77,11 @@ pub trait RotationalElements {
 
     fn prime_meridian_coefficients() -> PolynomialCoefficients;
 
-    fn theta(t: f64) -> [f64; N_COEFFICIENTS] {
+    fn theta(t: f64) -> Vec<f64> {
         let t = t / SECONDS_PER_JULIAN_CENTURY;
         let (theta0, theta1) = Self::nutation_precession_coefficients();
-        let mut theta = [0.0; N_COEFFICIENTS];
-        for i in 0..N_COEFFICIENTS {
+        let mut theta = Vec::with_capacity(theta0.len());
+        for i in 0..theta.len() {
             theta[i] = theta0[i] + theta1[i] * t;
         }
         theta
@@ -99,8 +91,8 @@ pub trait RotationalElements {
         let dt = SECONDS_PER_JULIAN_CENTURY;
         let (c0, c1, c2, c) = Self::right_ascension_coefficients();
         let theta = Self::theta(t);
-        let mut c_trig = [0.0; N_COEFFICIENTS];
-        for i in 0..N_COEFFICIENTS {
+        let mut c_trig = Vec::with_capacity(c.len());
+        for i in 0..c.len() {
             c_trig[i] = c[i] * theta[i].sin();
         }
         let c_trig: f64 = c_trig.iter().sum();
@@ -112,8 +104,8 @@ pub trait RotationalElements {
         let (_, c1, c2, c) = Self::right_ascension_coefficients();
         let (_, theta1) = Self::nutation_precession_coefficients();
         let theta = Self::theta(t);
-        let mut c_trig = [0.0; N_COEFFICIENTS];
-        for i in 0..N_COEFFICIENTS {
+        let mut c_trig = Vec::with_capacity(c.len());
+        for i in 0..c.len() {
             c_trig[i] = c[i] * theta1[i] / SECONDS_PER_JULIAN_CENTURY * theta[i].cos()
         }
         let c_trig: f64 = c_trig.iter().sum();
@@ -124,8 +116,8 @@ pub trait RotationalElements {
         let dt = SECONDS_PER_JULIAN_CENTURY;
         let (c0, c1, c2, c) = Self::declination_coefficients();
         let theta = Self::theta(t);
-        let mut c_trig = [0.0; N_COEFFICIENTS];
-        for i in 0..N_COEFFICIENTS {
+        let mut c_trig = Vec::with_capacity(c.len());
+        for i in 0..c.len() {
             c_trig[i] = c[i] * theta[i].cos();
         }
         let c_trig: f64 = c_trig.iter().sum();
@@ -137,8 +129,8 @@ pub trait RotationalElements {
         let (_, c1, c2, c) = Self::declination_coefficients();
         let (_, theta1) = Self::nutation_precession_coefficients();
         let theta = Self::theta(t);
-        let mut c_trig = [0.0; N_COEFFICIENTS];
-        for i in 0..N_COEFFICIENTS {
+        let mut c_trig = Vec::with_capacity(c.len());
+        for i in 0..c.len() {
             c_trig[i] = c[i] * theta1[i] / SECONDS_PER_JULIAN_CENTURY * theta[i].sin()
         }
         let c_trig: f64 = c_trig.iter().sum();
@@ -149,8 +141,8 @@ pub trait RotationalElements {
         let dt = SECONDS_PER_DAY;
         let (c0, c1, c2, c) = Self::prime_meridian_coefficients();
         let theta = Self::theta(t);
-        let mut c_trig = [0.0; N_COEFFICIENTS];
-        for i in 0..N_COEFFICIENTS {
+        let mut c_trig = Vec::with_capacity(c.len());
+        for i in 0..c.len() {
             c_trig[i] = c[i] * theta[i].sin();
         }
         let c_trig: f64 = c_trig.iter().sum();
@@ -162,8 +154,8 @@ pub trait RotationalElements {
         let (_, c1, c2, c) = Self::prime_meridian_coefficients();
         let (_, theta1) = Self::nutation_precession_coefficients();
         let theta = Self::theta(t);
-        let mut c_trig = [0.0; N_COEFFICIENTS];
-        for i in 0..N_COEFFICIENTS {
+        let mut c_trig = Vec::with_capacity(c.len());
+        for i in 0..c.len() {
             c_trig[i] = c[i] * theta1[i] / SECONDS_PER_JULIAN_CENTURY * theta[i].cos()
         }
         let c_trig: f64 = c_trig.iter().sum();
@@ -171,118 +163,6 @@ pub trait RotationalElements {
     }
 }
 
-impl RotationalElements for planets::Jupiter {
-    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
-        (
-            [
-                1.2796754075622423,
-                0.42970006184100396,
-                4.9549897464119015,
-                6.2098814785958245,
-                2.092649773141201,
-                4.010766621082969,
-                6.147922290150026,
-                1.9783307071355725,
-                2.5593508151244846,
-                0.8594001236820079,
-                1.734171606432425,
-                3.0699533280603655,
-                5.241627996900319,
-                1.9898901100379935,
-                0.864134346731335,
-                0.0,
-                0.0,
-                0.0,
-            ],
-            [
-                1596.503281347521,
-                787.7927551311844,
-                84.66068602648895,
-                20.792107379008446,
-                4.574507969477138,
-                1.1222467090323538,
-                41.58421475801689,
-                105.9414855960558,
-                3193.006562695042,
-                1575.5855102623689,
-                84.65553032387855,
-                20.80363527871787,
-                4.582318317879813,
-                105.94580703128374,
-                1.1222467090323538,
-                0.0,
-                0.0,
-                0.0,
-            ],
-        )
-    }
-
-    fn right_ascension_coefficients() -> PolynomialCoefficients {
-        (
-            4.6784701644349695,
-            -0.00011342894808711148,
-            0.0,
-            [
-                0.0,
-                0.0,
-                0.0,
-                0.0,
-                0.0,
-                0.0,
-                0.0,
-                0.0,
-                0.0,
-                0.0,
-                2.0420352248333656e-6,
-                1.6371188383706813e-5,
-                2.4993114888558796e-5,
-                5.235987755982989e-7,
-                3.752457891787809e-5,
-                0.0,
-                0.0,
-                0.0,
-            ],
-        )
-    }
-
-    fn declination_coefficients() -> PolynomialCoefficients {
-        (
-            1.1256553894213766,
-            4.211479485062318e-5,
-            0.0,
-            [
-                0.0,
-                0.0,
-                0.0,
-                0.0,
-                0.0,
-                0.0,
-                0.0,
-                0.0,
-                0.0,
-                0.0,
-                8.726646259971648e-7,
-                7.051130178057092e-6,
-                1.0768681484805013e-5,
-                -2.2689280275926283e-7,
-                1.616174887346749e-5,
-                0.0,
-                0.0,
-                0.0,
-            ],
-        )
-    }
-
-    fn prime_meridian_coefficients() -> PolynomialCoefficients {
-        (
-            4.973315703557842,
-            15.193719457141356,
-            0.0,
-            [0.0; N_COEFFICIENTS],
-        )
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use float_eq::assert_float_eq;
diff --git a/crates/lox_core/src/bodies/barycenters.rs b/crates/lox_core/src/bodies/barycenters.rs
index b05545a2..c1116a83 100644
--- a/crates/lox_core/src/bodies/barycenters.rs
+++ b/crates/lox_core/src/bodies/barycenters.rs
@@ -8,7 +8,7 @@
 
 // Auto-generated by `lox_gen`. Do not edit!
 
-use super::{BarycenterTrigRotationalElements, NaifId, PointMass, PolynomialCoefficient};
+use super::{NaifId, PointMass};
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct SolarSystemBarycenter;
 impl NaifId for SolarSystemBarycenter {
@@ -28,21 +28,6 @@ impl PointMass for MercuryBarycenter {
         22031.868551400003f64
     }
 }
-#[allow(clippy::approx_constant)]
-impl BarycenterTrigRotationalElements for MercuryBarycenter {
-    const NUT_PREC_ANGLES: &'static [PolynomialCoefficient] = &[
-        174.7910857f64,
-        149472.53587500003f64,
-        349.5821714f64,
-        298945.07175000006f64,
-        164.3732571f64,
-        448417.60762500006f64,
-        339.1643429f64,
-        597890.1435000001f64,
-        153.9554286f64,
-        747362.679375f64,
-    ];
-}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct VenusBarycenter;
 impl NaifId for VenusBarycenter {
@@ -67,37 +52,6 @@ impl PointMass for EarthBarycenter {
         403503.2356254802f64
     }
 }
-#[allow(clippy::approx_constant)]
-impl BarycenterTrigRotationalElements for EarthBarycenter {
-    const NUT_PREC_ANGLES: &'static [PolynomialCoefficient] = &[
-        125.045f64,
-        -1935.5364525f64,
-        250.089f64,
-        -3871.072905f64,
-        260.008f64,
-        475263.3328725f64,
-        176.625f64,
-        487269.629985f64,
-        357.529f64,
-        35999.0509575f64,
-        311.589f64,
-        964468.49931f64,
-        134.963f64,
-        477198.869325f64,
-        276.617f64,
-        12006.300765f64,
-        34.226f64,
-        63863.5132425f64,
-        15.134f64,
-        -5806.6093575f64,
-        119.743f64,
-        131.84064f64,
-        239.961f64,
-        6003.1503825f64,
-        25.053f64,
-        473327.79642f64,
-    ];
-}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct MarsBarycenter;
 impl NaifId for MarsBarycenter {
@@ -110,89 +64,6 @@ impl PointMass for MarsBarycenter {
         42828.3758157561f64
     }
 }
-#[allow(clippy::approx_constant)]
-impl BarycenterTrigRotationalElements for MarsBarycenter {
-    const NUT_PREC_ANGLES: &'static [PolynomialCoefficient] = &[
-        190.72646643f64,
-        15917.10818695f64,
-        0f64,
-        21.4689247f64,
-        31834.27934054f64,
-        0f64,
-        332.86082793f64,
-        19139.89694742f64,
-        0f64,
-        394.93256437f64,
-        38280.79631835f64,
-        0f64,
-        189.6327156f64,
-        41215158.1842005f64,
-        12.711923222f64,
-        121.46893664f64,
-        660.22803474f64,
-        0f64,
-        231.05028581f64,
-        660.9912354f64,
-        0f64,
-        251.37314025f64,
-        1320.50145245f64,
-        0f64,
-        217.98635955f64,
-        38279.9612555f64,
-        0f64,
-        196.19729402f64,
-        19139.83628608f64,
-        0f64,
-        198.991226f64,
-        19139.4819985f64,
-        0f64,
-        226.292679f64,
-        38280.8511281f64,
-        0f64,
-        249.663391f64,
-        57420.7251593f64,
-        0f64,
-        266.18351f64,
-        76560.636795f64,
-        0f64,
-        79.398797f64,
-        0.5042615f64,
-        0f64,
-        122.433576f64,
-        19139.9407476f64,
-        0f64,
-        43.058401f64,
-        38280.8753272f64,
-        0f64,
-        57.663379f64,
-        57420.7517205f64,
-        0f64,
-        79.476401f64,
-        76560.6495004f64,
-        0f64,
-        166.325722f64,
-        0.5042615f64,
-        0f64,
-        129.071773f64,
-        19140.0328244f64,
-        0f64,
-        36.352167f64,
-        38281.0473591f64,
-        0f64,
-        56.668646f64,
-        57420.929536f64,
-        0f64,
-        67.364003f64,
-        76560.2552215f64,
-        0f64,
-        104.79268f64,
-        95700.4387578f64,
-        0f64,
-        95.391654f64,
-        0.5042615f64,
-        0f64,
-    ];
-}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct JupiterBarycenter;
 impl NaifId for JupiterBarycenter {
@@ -205,41 +76,6 @@ impl PointMass for JupiterBarycenter {
         126712764.09999998f64
     }
 }
-#[allow(clippy::approx_constant)]
-impl BarycenterTrigRotationalElements for JupiterBarycenter {
-    const NUT_PREC_ANGLES: &'static [PolynomialCoefficient] = &[
-        73.32f64,
-        91472.9f64,
-        24.62f64,
-        45137.2f64,
-        283.9f64,
-        4850.7f64,
-        355.8f64,
-        1191.3f64,
-        119.9f64,
-        262.1f64,
-        229.8f64,
-        64.3f64,
-        352.25f64,
-        2382.6f64,
-        113.35f64,
-        6070f64,
-        146.64f64,
-        182945.8f64,
-        49.24f64,
-        90274.4f64,
-        99.360714f64,
-        4850.4046f64,
-        175.895369f64,
-        1191.9605f64,
-        300.323162f64,
-        262.5475f64,
-        114.012305f64,
-        6070.2476f64,
-        49.511251f64,
-        64.3f64,
-    ];
-}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct SaturnBarycenter;
 impl NaifId for SaturnBarycenter {
@@ -252,27 +88,6 @@ impl PointMass for SaturnBarycenter {
         37940584.8418f64
     }
 }
-#[allow(clippy::approx_constant)]
-impl BarycenterTrigRotationalElements for SaturnBarycenter {
-    const NUT_PREC_ANGLES: &'static [PolynomialCoefficient] = &[
-        353.32f64,
-        75706.7f64,
-        28.72f64,
-        75706.7f64,
-        177.4f64,
-        -36505.5f64,
-        300f64,
-        -7225.9f64,
-        316.45f64,
-        506.2f64,
-        345.2f64,
-        -1016.3f64,
-        706.64f64,
-        151413.4f64,
-        57.44f64,
-        151413.4f64,
-    ];
-}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct UranusBarycenter;
 impl NaifId for UranusBarycenter {
@@ -285,47 +100,6 @@ impl PointMass for UranusBarycenter {
         5794556.3999999985f64
     }
 }
-#[allow(clippy::approx_constant)]
-impl BarycenterTrigRotationalElements for UranusBarycenter {
-    const NUT_PREC_ANGLES: &'static [PolynomialCoefficient] = &[
-        115.75f64,
-        54991.87f64,
-        141.69f64,
-        41887.66f64,
-        135.03f64,
-        29927.35f64,
-        61.77f64,
-        25733.59f64,
-        249.32f64,
-        24471.46f64,
-        43.86f64,
-        22278.41f64,
-        77.66f64,
-        20289.42f64,
-        157.36f64,
-        16652.76f64,
-        101.81f64,
-        12872.63f64,
-        138.64f64,
-        8061.81f64,
-        102.23f64,
-        -2024.22f64,
-        316.41f64,
-        2863.96f64,
-        304.01f64,
-        -51.94f64,
-        308.71f64,
-        -93.17f64,
-        340.82f64,
-        -75.32f64,
-        259.14f64,
-        -504.81f64,
-        204.46f64,
-        -4048.44f64,
-        632.82f64,
-        5727.92f64,
-    ];
-}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct NeptuneBarycenter;
 impl NaifId for NeptuneBarycenter {
@@ -338,45 +112,6 @@ impl PointMass for NeptuneBarycenter {
         6836527.100580399f64
     }
 }
-#[allow(clippy::approx_constant)]
-impl BarycenterTrigRotationalElements for NeptuneBarycenter {
-    const NUT_PREC_ANGLES: &'static [PolynomialCoefficient] = &[
-        357.85f64,
-        52.316f64,
-        323.92f64,
-        62606.6f64,
-        220.51f64,
-        55064.2f64,
-        354.27f64,
-        46564.5f64,
-        75.31f64,
-        26109.4f64,
-        35.36f64,
-        14325.4f64,
-        142.61f64,
-        2824.6f64,
-        177.85f64,
-        52.316f64,
-        647.84f64,
-        125213.2f64,
-        355.7f64,
-        104.632f64,
-        533.55f64,
-        156.948f64,
-        711.4f64,
-        209.264f64,
-        889.25f64,
-        261.58f64,
-        1067.1f64,
-        313.896f64,
-        1244.95f64,
-        366.212f64,
-        1422.8f64,
-        418.528f64,
-        1600.65f64,
-        470.844f64,
-    ];
-}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct PlutoBarycenter;
 impl NaifId for PlutoBarycenter {
@@ -409,24 +144,6 @@ mod tests {
         );
     }
     #[test]
-    fn test_barycenter_trig_rotational_elements_nut_prec_angles_1() {
-        assert_eq!(
-            &[
-                174.7910857f64,
-                149472.53587500003f64,
-                349.5821714f64,
-                298945.07175000006f64,
-                164.3732571f64,
-                448417.60762500006f64,
-                339.1643429f64,
-                597890.1435000001f64,
-                153.9554286f64,
-                747362.679375f64
-            ],
-            MercuryBarycenter::NUT_PREC_ANGLES
-        )
-    }
-    #[test]
     fn test_naif_id_2() {
         assert_eq!(VenusBarycenter::id(), 2i32)
     }
@@ -446,40 +163,6 @@ mod tests {
         );
     }
     #[test]
-    fn test_barycenter_trig_rotational_elements_nut_prec_angles_3() {
-        assert_eq!(
-            &[
-                125.045f64,
-                -1935.5364525f64,
-                250.089f64,
-                -3871.072905f64,
-                260.008f64,
-                475263.3328725f64,
-                176.625f64,
-                487269.629985f64,
-                357.529f64,
-                35999.0509575f64,
-                311.589f64,
-                964468.49931f64,
-                134.963f64,
-                477198.869325f64,
-                276.617f64,
-                12006.300765f64,
-                34.226f64,
-                63863.5132425f64,
-                15.134f64,
-                -5806.6093575f64,
-                119.743f64,
-                131.84064f64,
-                239.961f64,
-                6003.1503825f64,
-                25.053f64,
-                473327.79642f64
-            ],
-            EarthBarycenter::NUT_PREC_ANGLES
-        )
-    }
-    #[test]
     fn test_naif_id_4() {
         assert_eq!(MarsBarycenter::id(), 4i32)
     }
@@ -491,92 +174,6 @@ mod tests {
         );
     }
     #[test]
-    fn test_barycenter_trig_rotational_elements_nut_prec_angles_4() {
-        assert_eq!(
-            &[
-                190.72646643f64,
-                15917.10818695f64,
-                0f64,
-                21.4689247f64,
-                31834.27934054f64,
-                0f64,
-                332.86082793f64,
-                19139.89694742f64,
-                0f64,
-                394.93256437f64,
-                38280.79631835f64,
-                0f64,
-                189.6327156f64,
-                41215158.1842005f64,
-                12.711923222f64,
-                121.46893664f64,
-                660.22803474f64,
-                0f64,
-                231.05028581f64,
-                660.9912354f64,
-                0f64,
-                251.37314025f64,
-                1320.50145245f64,
-                0f64,
-                217.98635955f64,
-                38279.9612555f64,
-                0f64,
-                196.19729402f64,
-                19139.83628608f64,
-                0f64,
-                198.991226f64,
-                19139.4819985f64,
-                0f64,
-                226.292679f64,
-                38280.8511281f64,
-                0f64,
-                249.663391f64,
-                57420.7251593f64,
-                0f64,
-                266.18351f64,
-                76560.636795f64,
-                0f64,
-                79.398797f64,
-                0.5042615f64,
-                0f64,
-                122.433576f64,
-                19139.9407476f64,
-                0f64,
-                43.058401f64,
-                38280.8753272f64,
-                0f64,
-                57.663379f64,
-                57420.7517205f64,
-                0f64,
-                79.476401f64,
-                76560.6495004f64,
-                0f64,
-                166.325722f64,
-                0.5042615f64,
-                0f64,
-                129.071773f64,
-                19140.0328244f64,
-                0f64,
-                36.352167f64,
-                38281.0473591f64,
-                0f64,
-                56.668646f64,
-                57420.929536f64,
-                0f64,
-                67.364003f64,
-                76560.2552215f64,
-                0f64,
-                104.79268f64,
-                95700.4387578f64,
-                0f64,
-                95.391654f64,
-                0.5042615f64,
-                0f64
-            ],
-            MarsBarycenter::NUT_PREC_ANGLES
-        )
-    }
-    #[test]
     fn test_naif_id_5() {
         assert_eq!(JupiterBarycenter::id(), 5i32)
     }
@@ -588,44 +185,6 @@ mod tests {
         );
     }
     #[test]
-    fn test_barycenter_trig_rotational_elements_nut_prec_angles_5() {
-        assert_eq!(
-            &[
-                73.32f64,
-                91472.9f64,
-                24.62f64,
-                45137.2f64,
-                283.9f64,
-                4850.7f64,
-                355.8f64,
-                1191.3f64,
-                119.9f64,
-                262.1f64,
-                229.8f64,
-                64.3f64,
-                352.25f64,
-                2382.6f64,
-                113.35f64,
-                6070f64,
-                146.64f64,
-                182945.8f64,
-                49.24f64,
-                90274.4f64,
-                99.360714f64,
-                4850.4046f64,
-                175.895369f64,
-                1191.9605f64,
-                300.323162f64,
-                262.5475f64,
-                114.012305f64,
-                6070.2476f64,
-                49.511251f64,
-                64.3f64
-            ],
-            JupiterBarycenter::NUT_PREC_ANGLES
-        )
-    }
-    #[test]
     fn test_naif_id_6() {
         assert_eq!(SaturnBarycenter::id(), 6i32)
     }
@@ -637,30 +196,6 @@ mod tests {
         );
     }
     #[test]
-    fn test_barycenter_trig_rotational_elements_nut_prec_angles_6() {
-        assert_eq!(
-            &[
-                353.32f64,
-                75706.7f64,
-                28.72f64,
-                75706.7f64,
-                177.4f64,
-                -36505.5f64,
-                300f64,
-                -7225.9f64,
-                316.45f64,
-                506.2f64,
-                345.2f64,
-                -1016.3f64,
-                706.64f64,
-                151413.4f64,
-                57.44f64,
-                151413.4f64
-            ],
-            SaturnBarycenter::NUT_PREC_ANGLES
-        )
-    }
-    #[test]
     fn test_naif_id_7() {
         assert_eq!(UranusBarycenter::id(), 7i32)
     }
@@ -672,50 +207,6 @@ mod tests {
         );
     }
     #[test]
-    fn test_barycenter_trig_rotational_elements_nut_prec_angles_7() {
-        assert_eq!(
-            &[
-                115.75f64,
-                54991.87f64,
-                141.69f64,
-                41887.66f64,
-                135.03f64,
-                29927.35f64,
-                61.77f64,
-                25733.59f64,
-                249.32f64,
-                24471.46f64,
-                43.86f64,
-                22278.41f64,
-                77.66f64,
-                20289.42f64,
-                157.36f64,
-                16652.76f64,
-                101.81f64,
-                12872.63f64,
-                138.64f64,
-                8061.81f64,
-                102.23f64,
-                -2024.22f64,
-                316.41f64,
-                2863.96f64,
-                304.01f64,
-                -51.94f64,
-                308.71f64,
-                -93.17f64,
-                340.82f64,
-                -75.32f64,
-                259.14f64,
-                -504.81f64,
-                204.46f64,
-                -4048.44f64,
-                632.82f64,
-                5727.92f64
-            ],
-            UranusBarycenter::NUT_PREC_ANGLES
-        )
-    }
-    #[test]
     fn test_naif_id_8() {
         assert_eq!(NeptuneBarycenter::id(), 8i32)
     }
@@ -727,48 +218,6 @@ mod tests {
         );
     }
     #[test]
-    fn test_barycenter_trig_rotational_elements_nut_prec_angles_8() {
-        assert_eq!(
-            &[
-                357.85f64,
-                52.316f64,
-                323.92f64,
-                62606.6f64,
-                220.51f64,
-                55064.2f64,
-                354.27f64,
-                46564.5f64,
-                75.31f64,
-                26109.4f64,
-                35.36f64,
-                14325.4f64,
-                142.61f64,
-                2824.6f64,
-                177.85f64,
-                52.316f64,
-                647.84f64,
-                125213.2f64,
-                355.7f64,
-                104.632f64,
-                533.55f64,
-                156.948f64,
-                711.4f64,
-                209.264f64,
-                889.25f64,
-                261.58f64,
-                1067.1f64,
-                313.896f64,
-                1244.95f64,
-                366.212f64,
-                1422.8f64,
-                418.528f64,
-                1600.65f64,
-                470.844f64
-            ],
-            NeptuneBarycenter::NUT_PREC_ANGLES
-        )
-    }
-    #[test]
     fn test_naif_id_9() {
         assert_eq!(PlutoBarycenter::id(), 9i32)
     }
diff --git a/crates/lox_core/src/bodies/minor.rs b/crates/lox_core/src/bodies/minor.rs
index df746075..d708f4d2 100644
--- a/crates/lox_core/src/bodies/minor.rs
+++ b/crates/lox_core/src/bodies/minor.rs
@@ -9,7 +9,8 @@
 // Auto-generated by `lox_gen`. Do not edit!
 
 use super::{
-    BodyRotationalElements, Ellipsoid, NaifId, PointMass, PolynomialCoefficient, TriAxial,
+    Ellipsoid, NaifId, NutationPrecessionCoefficients, PointMass, PolynomialCoefficients,
+    RotationalElements, TriAxial,
 };
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Gaspra;
@@ -35,11 +36,19 @@ impl TriAxial for Gaspra {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Gaspra {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [9.47f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [26.7f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [83.67f64, 1226.911485f64, 0f64];
+impl RotationalElements for Gaspra {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (9.47f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (26.7f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (83.67f64, 1226.911485f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Ida;
@@ -65,11 +74,19 @@ impl TriAxial for Ida {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Ida {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [168.76f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-87.12f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [274.05f64, 1864.628007f64, 0f64];
+impl RotationalElements for Ida {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (168.76f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (-87.12f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (274.05f64, 1864.628007f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Dactyl;
@@ -78,6 +95,21 @@ impl NaifId for Dactyl {
         2431011i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Dactyl {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Ceres;
 impl NaifId for Ceres {
@@ -107,10 +139,19 @@ impl TriAxial for Ceres {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Ceres {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [291.418f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [66.764f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = [170.65f64, 952.1532f64, 0f64];
+impl RotationalElements for Ceres {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (291.418f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (66.764f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (170.65f64, 952.1532f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Pallas;
@@ -125,10 +166,19 @@ impl PointMass for Pallas {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Pallas {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [33f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-3f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = [38f64, 1105.8036f64, 0f64];
+impl RotationalElements for Pallas {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (33f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (-3f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (38f64, 1105.8036f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Vesta;
@@ -159,11 +209,19 @@ impl TriAxial for Vesta {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Vesta {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [309.031f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [42.235f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [285.39f64, 1617.3329428f64, 0f64];
+impl RotationalElements for Vesta {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (309.031f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (42.235f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (285.39f64, 1617.3329428f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Psyche;
@@ -193,6 +251,21 @@ impl TriAxial for Psyche {
         116f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Psyche {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Lutetia;
 impl NaifId for Lutetia {
@@ -217,10 +290,19 @@ impl TriAxial for Lutetia {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Lutetia {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [52f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [12f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = [94f64, 1057.7515f64, 0f64];
+impl RotationalElements for Lutetia {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (52f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (12f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (94f64, 1057.7515f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Kleopatra;
@@ -229,6 +311,21 @@ impl NaifId for Kleopatra {
         2000216i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Kleopatra {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Eros;
 impl NaifId for Eros {
@@ -258,11 +355,19 @@ impl TriAxial for Eros {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Eros {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [11.35f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [17.22f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [326.07f64, 1639.38864745f64, 0f64];
+impl RotationalElements for Eros {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (11.35f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (17.22f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (326.07f64, 1639.38864745f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Davida;
@@ -293,11 +398,19 @@ impl TriAxial for Davida {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Davida {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [297f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [5f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [268.1f64, 1684.4193549f64, 0f64];
+impl RotationalElements for Davida {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (297f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (5f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (268.1f64, 1684.4193549f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Mathilde;
@@ -322,6 +435,21 @@ impl TriAxial for Mathilde {
         24f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Mathilde {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Steins;
 impl NaifId for Steins {
@@ -346,11 +474,19 @@ impl TriAxial for Steins {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Steins {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [91f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-62f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [321.76f64, 1428.09917f64, 0f64];
+impl RotationalElements for Steins {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (91f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (-62f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (321.76f64, 1428.09917f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Braille;
@@ -359,6 +495,21 @@ impl NaifId for Braille {
         2009969i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Braille {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct WilsonHarrington;
 impl NaifId for WilsonHarrington {
@@ -366,6 +517,21 @@ impl NaifId for WilsonHarrington {
         2004015i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for WilsonHarrington {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Toutatis;
 impl NaifId for Toutatis {
@@ -389,6 +555,21 @@ impl TriAxial for Toutatis {
         1.015f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Toutatis {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Itokawa;
 impl NaifId for Itokawa {
@@ -413,10 +594,19 @@ impl TriAxial for Itokawa {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Itokawa {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [90.53f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-66.3f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = [0f64, 712.143f64, 0f64];
+impl RotationalElements for Itokawa {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (90.53f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (-66.3f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 712.143f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Bennu;
@@ -425,6 +615,21 @@ impl NaifId for Bennu {
         2101955i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Bennu {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[cfg(test)]
 #[allow(clippy::approx_constant)]
 mod tests {
@@ -441,18 +646,31 @@ mod tests {
         assert_eq!(Gaspra::along_orbit_radius(), 5.2f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_9511010() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Gaspra::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_9511010() {
-        assert_eq!([9.47f64, 0f64, 0f64], Gaspra::RIGHT_ASCENSION_COEFFICIENTS)
+        assert_eq!(
+            (9.47f64, 0f64, 0f64, &[] as &[f64]),
+            Gaspra::right_ascension_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_9511010() {
-        assert_eq!([26.7f64, 0f64, 0f64], Gaspra::DECLINATION_COEFFICIENTS)
+        assert_eq!(
+            (26.7f64, 0f64, 0f64, &[] as &[f64]),
+            Gaspra::declination_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_9511010() {
         assert_eq!(
-            [83.67f64, 1226.911485f64, 0f64],
-            Gaspra::PRIME_MERIDIAN_COEFFICIENTS
+            (83.67f64, 1226.911485f64, 0f64, &[] as &[f64]),
+            Gaspra::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -467,18 +685,31 @@ mod tests {
         assert_eq!(Ida::along_orbit_radius(), 12f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_2431010() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Ida::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_2431010() {
-        assert_eq!([168.76f64, 0f64, 0f64], Ida::RIGHT_ASCENSION_COEFFICIENTS)
+        assert_eq!(
+            (168.76f64, 0f64, 0f64, &[] as &[f64]),
+            Ida::right_ascension_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_2431010() {
-        assert_eq!([-87.12f64, 0f64, 0f64], Ida::DECLINATION_COEFFICIENTS)
+        assert_eq!(
+            (-87.12f64, 0f64, 0f64, &[] as &[f64]),
+            Ida::declination_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_2431010() {
         assert_eq!(
-            [274.05f64, 1864.628007f64, 0f64],
-            Ida::PRIME_MERIDIAN_COEFFICIENTS
+            (274.05f64, 1864.628007f64, 0f64, &[] as &[f64]),
+            Ida::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -486,6 +717,34 @@ mod tests {
         assert_eq!(Dactyl::id(), 2431011i32)
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_2431011() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Dactyl::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_2431011() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Dactyl::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_2431011() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Dactyl::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_2431011() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Dactyl::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_2000001() {
         assert_eq!(Ceres::id(), 2000001i32)
     }
@@ -501,21 +760,31 @@ mod tests {
         assert_eq!(Ceres::along_orbit_radius(), 487.3f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_2000001() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Ceres::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_2000001() {
         assert_eq!(
-            [291.418f64, 0f64, 0f64],
-            Ceres::RIGHT_ASCENSION_COEFFICIENTS
+            (291.418f64, 0f64, 0f64, &[] as &[f64]),
+            Ceres::right_ascension_coefficients()
         )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_2000001() {
-        assert_eq!([66.764f64, 0f64, 0f64], Ceres::DECLINATION_COEFFICIENTS)
+        assert_eq!(
+            (66.764f64, 0f64, 0f64, &[] as &[f64]),
+            Ceres::declination_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_2000001() {
         assert_eq!(
-            [170.65f64, 952.1532f64, 0f64],
-            Ceres::PRIME_MERIDIAN_COEFFICIENTS
+            (170.65f64, 952.1532f64, 0f64, &[] as &[f64]),
+            Ceres::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -527,18 +796,31 @@ mod tests {
         assert_eq!(Pallas::gravitational_parameter(), 13.665878145967422f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_2000002() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Pallas::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_2000002() {
-        assert_eq!([33f64, 0f64, 0f64], Pallas::RIGHT_ASCENSION_COEFFICIENTS)
+        assert_eq!(
+            (33f64, 0f64, 0f64, &[] as &[f64]),
+            Pallas::right_ascension_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_2000002() {
-        assert_eq!([-3f64, 0f64, 0f64], Pallas::DECLINATION_COEFFICIENTS)
+        assert_eq!(
+            (-3f64, 0f64, 0f64, &[] as &[f64]),
+            Pallas::declination_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_2000002() {
         assert_eq!(
-            [38f64, 1105.8036f64, 0f64],
-            Pallas::PRIME_MERIDIAN_COEFFICIENTS
+            (38f64, 1105.8036f64, 0f64, &[] as &[f64]),
+            Pallas::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -557,21 +839,31 @@ mod tests {
         assert_eq!(Vesta::along_orbit_radius(), 280f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_2000004() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Vesta::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_2000004() {
         assert_eq!(
-            [309.031f64, 0f64, 0f64],
-            Vesta::RIGHT_ASCENSION_COEFFICIENTS
+            (309.031f64, 0f64, 0f64, &[] as &[f64]),
+            Vesta::right_ascension_coefficients()
         )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_2000004() {
-        assert_eq!([42.235f64, 0f64, 0f64], Vesta::DECLINATION_COEFFICIENTS)
+        assert_eq!(
+            (42.235f64, 0f64, 0f64, &[] as &[f64]),
+            Vesta::declination_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_2000004() {
         assert_eq!(
-            [285.39f64, 1617.3329428f64, 0f64],
-            Vesta::PRIME_MERIDIAN_COEFFICIENTS
+            (285.39f64, 1617.3329428f64, 0f64, &[] as &[f64]),
+            Vesta::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -590,6 +882,34 @@ mod tests {
         assert_eq!(Psyche::along_orbit_radius(), 116f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_2000016() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Psyche::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_2000016() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Psyche::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_2000016() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Psyche::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_2000016() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Psyche::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_2000021() {
         assert_eq!(Lutetia::id(), 2000021i32)
     }
@@ -601,18 +921,31 @@ mod tests {
         assert_eq!(Lutetia::along_orbit_radius(), 50.5f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_2000021() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Lutetia::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_2000021() {
-        assert_eq!([52f64, 0f64, 0f64], Lutetia::RIGHT_ASCENSION_COEFFICIENTS)
+        assert_eq!(
+            (52f64, 0f64, 0f64, &[] as &[f64]),
+            Lutetia::right_ascension_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_2000021() {
-        assert_eq!([12f64, 0f64, 0f64], Lutetia::DECLINATION_COEFFICIENTS)
+        assert_eq!(
+            (12f64, 0f64, 0f64, &[] as &[f64]),
+            Lutetia::declination_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_2000021() {
         assert_eq!(
-            [94f64, 1057.7515f64, 0f64],
-            Lutetia::PRIME_MERIDIAN_COEFFICIENTS
+            (94f64, 1057.7515f64, 0f64, &[] as &[f64]),
+            Lutetia::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -620,6 +953,34 @@ mod tests {
         assert_eq!(Kleopatra::id(), 2000216i32)
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_2000216() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Kleopatra::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_2000216() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kleopatra::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_2000216() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kleopatra::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_2000216() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kleopatra::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_2000433() {
         assert_eq!(Eros::id(), 2000433i32)
     }
@@ -635,18 +996,31 @@ mod tests {
         assert_eq!(Eros::along_orbit_radius(), 5.5f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_2000433() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Eros::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_2000433() {
-        assert_eq!([11.35f64, 0f64, 0f64], Eros::RIGHT_ASCENSION_COEFFICIENTS)
+        assert_eq!(
+            (11.35f64, 0f64, 0f64, &[] as &[f64]),
+            Eros::right_ascension_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_2000433() {
-        assert_eq!([17.22f64, 0f64, 0f64], Eros::DECLINATION_COEFFICIENTS)
+        assert_eq!(
+            (17.22f64, 0f64, 0f64, &[] as &[f64]),
+            Eros::declination_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_2000433() {
         assert_eq!(
-            [326.07f64, 1639.38864745f64, 0f64],
-            Eros::PRIME_MERIDIAN_COEFFICIENTS
+            (326.07f64, 1639.38864745f64, 0f64, &[] as &[f64]),
+            Eros::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -665,18 +1039,31 @@ mod tests {
         assert_eq!(Davida::along_orbit_radius(), 147f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_2000511() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Davida::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_2000511() {
-        assert_eq!([297f64, 0f64, 0f64], Davida::RIGHT_ASCENSION_COEFFICIENTS)
+        assert_eq!(
+            (297f64, 0f64, 0f64, &[] as &[f64]),
+            Davida::right_ascension_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_2000511() {
-        assert_eq!([5f64, 0f64, 0f64], Davida::DECLINATION_COEFFICIENTS)
+        assert_eq!(
+            (5f64, 0f64, 0f64, &[] as &[f64]),
+            Davida::declination_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_2000511() {
         assert_eq!(
-            [268.1f64, 1684.4193549f64, 0f64],
-            Davida::PRIME_MERIDIAN_COEFFICIENTS
+            (268.1f64, 1684.4193549f64, 0f64, &[] as &[f64]),
+            Davida::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -691,6 +1078,34 @@ mod tests {
         assert_eq!(Mathilde::along_orbit_radius(), 24f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_2000253() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Mathilde::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_2000253() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Mathilde::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_2000253() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Mathilde::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_2000253() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Mathilde::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_2002867() {
         assert_eq!(Steins::id(), 2002867i32)
     }
@@ -702,18 +1117,31 @@ mod tests {
         assert_eq!(Steins::along_orbit_radius(), 2.73f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_2002867() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Steins::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_2002867() {
-        assert_eq!([91f64, 0f64, 0f64], Steins::RIGHT_ASCENSION_COEFFICIENTS)
+        assert_eq!(
+            (91f64, 0f64, 0f64, &[] as &[f64]),
+            Steins::right_ascension_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_2002867() {
-        assert_eq!([-62f64, 0f64, 0f64], Steins::DECLINATION_COEFFICIENTS)
+        assert_eq!(
+            (-62f64, 0f64, 0f64, &[] as &[f64]),
+            Steins::declination_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_2002867() {
         assert_eq!(
-            [321.76f64, 1428.09917f64, 0f64],
-            Steins::PRIME_MERIDIAN_COEFFICIENTS
+            (321.76f64, 1428.09917f64, 0f64, &[] as &[f64]),
+            Steins::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -721,10 +1149,66 @@ mod tests {
         assert_eq!(Braille::id(), 2009969i32)
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_2009969() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Braille::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_2009969() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Braille::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_2009969() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Braille::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_2009969() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Braille::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_2004015() {
         assert_eq!(WilsonHarrington::id(), 2004015i32)
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_2004015() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            WilsonHarrington::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_2004015() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            WilsonHarrington::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_2004015() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            WilsonHarrington::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_2004015() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            WilsonHarrington::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_2004179() {
         assert_eq!(Toutatis::id(), 2004179i32)
     }
@@ -736,6 +1220,34 @@ mod tests {
         assert_eq!(Toutatis::along_orbit_radius(), 1.015f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_2004179() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Toutatis::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_2004179() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Toutatis::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_2004179() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Toutatis::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_2004179() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Toutatis::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_2025143() {
         assert_eq!(Itokawa::id(), 2025143i32)
     }
@@ -747,25 +1259,63 @@ mod tests {
         assert_eq!(Itokawa::along_orbit_radius(), 0.147f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_2025143() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Itokawa::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_2025143() {
         assert_eq!(
-            [90.53f64, 0f64, 0f64],
-            Itokawa::RIGHT_ASCENSION_COEFFICIENTS
+            (90.53f64, 0f64, 0f64, &[] as &[f64]),
+            Itokawa::right_ascension_coefficients()
         )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_2025143() {
-        assert_eq!([-66.3f64, 0f64, 0f64], Itokawa::DECLINATION_COEFFICIENTS)
+        assert_eq!(
+            (-66.3f64, 0f64, 0f64, &[] as &[f64]),
+            Itokawa::declination_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_2025143() {
         assert_eq!(
-            [0f64, 712.143f64, 0f64],
-            Itokawa::PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 712.143f64, 0f64, &[] as &[f64]),
+            Itokawa::prime_meridian_coefficients()
         )
     }
     #[test]
     fn test_naif_id_2101955() {
         assert_eq!(Bennu::id(), 2101955i32)
     }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_2101955() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Bennu::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_2101955() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Bennu::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_2101955() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Bennu::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_2101955() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Bennu::prime_meridian_coefficients()
+        )
+    }
 }
diff --git a/crates/lox_core/src/bodies/planets.rs b/crates/lox_core/src/bodies/planets.rs
index bbd6eb4c..87f11b7d 100644
--- a/crates/lox_core/src/bodies/planets.rs
+++ b/crates/lox_core/src/bodies/planets.rs
@@ -9,8 +9,8 @@
 // Auto-generated by `lox_gen`. Do not edit!
 
 use super::{
-    BodyRotationalElements, BodyTrigRotationalElements, Ellipsoid, NaifId, PointMass,
-    PolynomialCoefficient, Spheroid,
+    Ellipsoid, NaifId, NutationPrecessionCoefficients, PointMass, PolynomialCoefficients,
+    RotationalElements, Spheroid,
 };
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Mercury;
@@ -38,26 +38,55 @@ impl Spheroid for Mercury {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Mercury {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [281.0103f64, -0.0328f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [61.4155f64, -0.0049f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [329.5988f64, 6.1385108f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Mercury {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, 0f64, 0f64];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, 0f64, 0f64];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0.01067257f64,
-        -0.00112309f64,
-        -0.0001104f64,
-        -0.00002539f64,
-        -0.00000571f64,
-    ];
+impl RotationalElements for Mercury {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (
+            &[
+                174.7910857f64,
+                349.5821714f64,
+                164.3732571f64,
+                339.1643429f64,
+                153.9554286f64,
+            ] as &[f64],
+            &[
+                149472.53587500003f64,
+                298945.07175000006f64,
+                448417.60762500006f64,
+                597890.1435000001f64,
+                747362.679375f64,
+            ] as &[f64],
+        )
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            281.0103f64,
+            -0.0328f64,
+            0f64,
+            &[0f64, 0f64, 0f64, 0f64, 0f64] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            61.4155f64,
+            -0.0049f64,
+            0f64,
+            &[0f64, 0f64, 0f64, 0f64, 0f64] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            329.5988f64,
+            6.1385108f64,
+            0f64,
+            &[
+                0.01067257f64,
+                -0.00112309f64,
+                -0.0001104f64,
+                -0.00002539f64,
+                -0.00000571f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Venus;
@@ -85,10 +114,19 @@ impl Spheroid for Venus {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Venus {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [272.76f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [67.16f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = [160.2f64, -1.4813688f64, 0f64];
+impl RotationalElements for Venus {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (272.76f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (67.16f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (160.2f64, -1.4813688f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Earth;
@@ -116,11 +154,39 @@ impl Spheroid for Earth {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Earth {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [0f64, -0.641f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [90f64, -0.557f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [190.147f64, 360.9856235f64, 0f64];
+impl RotationalElements for Earth {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (
+            &[
+                125.045f64, 250.089f64, 260.008f64, 176.625f64, 357.529f64, 311.589f64, 134.963f64,
+                276.617f64, 34.226f64, 15.134f64, 119.743f64, 239.961f64, 25.053f64,
+            ] as &[f64],
+            &[
+                -1935.5364525f64,
+                -3871.072905f64,
+                475263.3328725f64,
+                487269.629985f64,
+                35999.0509575f64,
+                964468.49931f64,
+                477198.869325f64,
+                12006.300765f64,
+                63863.5132425f64,
+                -5806.6093575f64,
+                131.84064f64,
+                6003.1503825f64,
+                473327.79642f64,
+            ] as &[f64],
+        )
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, -0.641f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (90f64, -0.557f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (190.147f64, 360.9856235f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Mars;
@@ -148,83 +214,181 @@ impl Spheroid for Mars {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Mars {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [317.269202f64, -0.10927547f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [54.432516f64, -0.05827105f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [176.049863f64, 350.891982443297f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Mars {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0.000068f64,
-        0.000238f64,
-        0.000052f64,
-        0.000009f64,
-        0.419057f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0.000051f64,
-        0.000141f64,
-        0.000031f64,
-        0.000005f64,
-        1.591274f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0.000145f64,
-        0.000157f64,
-        0.00004f64,
-        0.000001f64,
-        0.000001f64,
-        0.584542f64,
-    ];
+impl RotationalElements for Mars {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (
+            &[
+                190.72646643f64,
+                0f64,
+                31834.27934054f64,
+                332.86082793f64,
+                0f64,
+                38280.79631835f64,
+                189.6327156f64,
+                12.711923222f64,
+                660.22803474f64,
+                231.05028581f64,
+                0f64,
+                1320.50145245f64,
+                217.98635955f64,
+                0f64,
+                19139.83628608f64,
+                198.991226f64,
+                0f64,
+                38280.8511281f64,
+                249.663391f64,
+                0f64,
+                76560.636795f64,
+                79.398797f64,
+                0f64,
+                19139.9407476f64,
+                43.058401f64,
+                0f64,
+                57420.7517205f64,
+                79.476401f64,
+                0f64,
+                0.5042615f64,
+                129.071773f64,
+                0f64,
+                38281.0473591f64,
+                56.668646f64,
+                0f64,
+                76560.2552215f64,
+                104.79268f64,
+                0f64,
+                0.5042615f64,
+            ] as &[f64],
+            &[
+                15917.10818695f64,
+                21.4689247f64,
+                0f64,
+                19139.89694742f64,
+                394.93256437f64,
+                0f64,
+                41215158.1842005f64,
+                121.46893664f64,
+                0f64,
+                660.9912354f64,
+                251.37314025f64,
+                0f64,
+                38279.9612555f64,
+                196.19729402f64,
+                0f64,
+                19139.4819985f64,
+                226.292679f64,
+                0f64,
+                57420.7251593f64,
+                266.18351f64,
+                0f64,
+                0.5042615f64,
+                122.433576f64,
+                0f64,
+                38280.8753272f64,
+                57.663379f64,
+                0f64,
+                76560.6495004f64,
+                166.325722f64,
+                0f64,
+                19140.0328244f64,
+                36.352167f64,
+                0f64,
+                57420.929536f64,
+                67.364003f64,
+                0f64,
+                95700.4387578f64,
+                95.391654f64,
+                0f64,
+            ] as &[f64],
+        )
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            317.269202f64,
+            -0.10927547f64,
+            0f64,
+            &[
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0.000068f64,
+                0.000238f64,
+                0.000052f64,
+                0.000009f64,
+                0.419057f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            54.432516f64,
+            -0.05827105f64,
+            0f64,
+            &[
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0.000051f64,
+                0.000141f64,
+                0.000031f64,
+                0.000005f64,
+                1.591274f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            176.049863f64,
+            350.891982443297f64,
+            0f64,
+            &[
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0.000145f64,
+                0.000157f64,
+                0.00004f64,
+                0.000001f64,
+                0.000001f64,
+                0.584542f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Jupiter;
@@ -252,51 +416,104 @@ impl Spheroid for Jupiter {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Jupiter {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [268.056595f64, -0.006499f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [64.495303f64, 0.002413f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = [284.95f64, 870.536f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Jupiter {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0.000117f64,
-        0.000938f64,
-        0.001432f64,
-        0.00003f64,
-        0.00215f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0.00005f64,
-        0.000404f64,
-        0.000617f64,
-        -0.000013f64,
-        0.000926f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-    ];
+impl RotationalElements for Jupiter {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (
+            &[
+                73.32f64,
+                24.62f64,
+                283.9f64,
+                355.8f64,
+                119.9f64,
+                229.8f64,
+                352.25f64,
+                113.35f64,
+                146.64f64,
+                49.24f64,
+                99.360714f64,
+                175.895369f64,
+                300.323162f64,
+                114.012305f64,
+                49.511251f64,
+            ] as &[f64],
+            &[
+                91472.9f64,
+                45137.2f64,
+                4850.7f64,
+                1191.3f64,
+                262.1f64,
+                64.3f64,
+                2382.6f64,
+                6070f64,
+                182945.8f64,
+                90274.4f64,
+                4850.4046f64,
+                1191.9605f64,
+                262.5475f64,
+                6070.2476f64,
+                64.3f64,
+            ] as &[f64],
+        )
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            268.056595f64,
+            -0.006499f64,
+            0f64,
+            &[
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0.000117f64,
+                0.000938f64,
+                0.001432f64,
+                0.00003f64,
+                0.00215f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            64.495303f64,
+            0.002413f64,
+            0f64,
+            &[
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0.00005f64,
+                0.000404f64,
+                0.000617f64,
+                -0.000013f64,
+                0.000926f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            284.95f64,
+            870.536f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Saturn;
@@ -324,10 +541,33 @@ impl Spheroid for Saturn {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Saturn {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [40.589f64, -0.036f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [83.537f64, -0.004f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = [38.9f64, 810.7939024f64, 0f64];
+impl RotationalElements for Saturn {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (
+            &[
+                353.32f64, 28.72f64, 177.4f64, 300f64, 316.45f64, 345.2f64, 706.64f64, 57.44f64,
+            ] as &[f64],
+            &[
+                75706.7f64,
+                75706.7f64,
+                -36505.5f64,
+                -7225.9f64,
+                506.2f64,
+                -1016.3f64,
+                151413.4f64,
+                151413.4f64,
+            ] as &[f64],
+        )
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (40.589f64, -0.036f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (83.537f64, -0.004f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (38.9f64, 810.7939024f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Uranus;
@@ -355,11 +595,45 @@ impl Spheroid for Uranus {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Uranus {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [257.311f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-15.175f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [203.81f64, -501.1600928f64, 0f64];
+impl RotationalElements for Uranus {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (
+            &[
+                115.75f64, 141.69f64, 135.03f64, 61.77f64, 249.32f64, 43.86f64, 77.66f64,
+                157.36f64, 101.81f64, 138.64f64, 102.23f64, 316.41f64, 304.01f64, 308.71f64,
+                340.82f64, 259.14f64, 204.46f64, 632.82f64,
+            ] as &[f64],
+            &[
+                54991.87f64,
+                41887.66f64,
+                29927.35f64,
+                25733.59f64,
+                24471.46f64,
+                22278.41f64,
+                20289.42f64,
+                16652.76f64,
+                12872.63f64,
+                8061.81f64,
+                -2024.22f64,
+                2863.96f64,
+                -51.94f64,
+                -93.17f64,
+                -75.32f64,
+                -504.81f64,
+                -4048.44f64,
+                5727.92f64,
+            ] as &[f64],
+        )
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (257.311f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (-15.175f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (203.81f64, -501.1600928f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Neptune;
@@ -387,20 +661,59 @@ impl Spheroid for Neptune {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Neptune {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [299.36f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [43.46f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [249.978f64, 541.1397757f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Neptune {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0.7f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[-0.51f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[-0.48f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64];
+impl RotationalElements for Neptune {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (
+            &[
+                357.85f64, 323.92f64, 220.51f64, 354.27f64, 75.31f64, 35.36f64, 142.61f64,
+                177.85f64, 647.84f64, 355.7f64, 533.55f64, 711.4f64, 889.25f64, 1067.1f64,
+                1244.95f64, 1422.8f64, 1600.65f64,
+            ] as &[f64],
+            &[
+                52.316f64,
+                62606.6f64,
+                55064.2f64,
+                46564.5f64,
+                26109.4f64,
+                14325.4f64,
+                2824.6f64,
+                52.316f64,
+                125213.2f64,
+                104.632f64,
+                156.948f64,
+                209.264f64,
+                261.58f64,
+                313.896f64,
+                366.212f64,
+                418.528f64,
+                470.844f64,
+            ] as &[f64],
+        )
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            299.36f64,
+            0f64,
+            0f64,
+            &[0.7f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            43.46f64,
+            0f64,
+            0f64,
+            &[-0.51f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            249.978f64,
+            541.1397757f64,
+            0f64,
+            &[-0.48f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Pluto;
@@ -428,11 +741,19 @@ impl Spheroid for Pluto {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Pluto {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [132.993f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-6.163f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [302.695f64, 56.3625225f64, 0f64];
+impl RotationalElements for Pluto {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (132.993f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (-6.163f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (302.695f64, 56.3625225f64, 0f64, &[] as &[f64])
+    }
 }
 #[cfg(test)]
 #[allow(clippy::approx_constant)]
@@ -453,51 +774,67 @@ mod tests {
         assert_eq!(Mercury::equatorial_radius(), 2440.53f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_199() {
+    fn test_rotational_elements_nutation_precession_coefficients_199() {
         assert_eq!(
-            [281.0103f64, -0.0328f64, 0f64],
-            Mercury::RIGHT_ASCENSION_COEFFICIENTS
+            (
+                &[
+                    174.7910857f64,
+                    349.5821714f64,
+                    164.3732571f64,
+                    339.1643429f64,
+                    153.9554286f64
+                ] as &[f64],
+                &[
+                    149472.53587500003f64,
+                    298945.07175000006f64,
+                    448417.60762500006f64,
+                    597890.1435000001f64,
+                    747362.679375f64
+                ] as &[f64]
+            ),
+            Mercury::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_199() {
-        assert_eq!(
-            [61.4155f64, -0.0049f64, 0f64],
-            Mercury::DECLINATION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_199() {
+    fn test_rotational_elements_right_ascension_coefficients_199() {
         assert_eq!(
-            [329.5988f64, 6.1385108f64, 0f64],
-            Mercury::PRIME_MERIDIAN_COEFFICIENTS
+            (
+                281.0103f64,
+                -0.0328f64,
+                0f64,
+                &[0f64, 0f64, 0f64, 0f64, 0f64] as &[f64]
+            ),
+            Mercury::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients199() {
+    fn test_rotational_elements_declination_coefficients_199() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, 0f64, 0f64],
-            Mercury::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                61.4155f64,
+                -0.0049f64,
+                0f64,
+                &[0f64, 0f64, 0f64, 0f64, 0f64] as &[f64]
+            ),
+            Mercury::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients199() {
+    fn test_rotational_elements_prime_meridian_coefficients_199() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, 0f64, 0f64],
-            Mercury::NUT_PREC_DECLINATION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients199() {
-        assert_eq!(
-            &[
-                0.01067257f64,
-                -0.00112309f64,
-                -0.0001104f64,
-                -0.00002539f64,
-                -0.00000571f64
-            ],
-            Mercury::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                329.5988f64,
+                6.1385108f64,
+                0f64,
+                &[
+                    0.01067257f64,
+                    -0.00112309f64,
+                    -0.0001104f64,
+                    -0.00002539f64,
+                    -0.00000571f64
+                ] as &[f64]
+            ),
+            Mercury::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -515,18 +852,31 @@ mod tests {
         assert_eq!(Venus::equatorial_radius(), 6051.8f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_299() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Venus::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_299() {
-        assert_eq!([272.76f64, 0f64, 0f64], Venus::RIGHT_ASCENSION_COEFFICIENTS)
+        assert_eq!(
+            (272.76f64, 0f64, 0f64, &[] as &[f64]),
+            Venus::right_ascension_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_299() {
-        assert_eq!([67.16f64, 0f64, 0f64], Venus::DECLINATION_COEFFICIENTS)
+        assert_eq!(
+            (67.16f64, 0f64, 0f64, &[] as &[f64]),
+            Venus::declination_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_299() {
         assert_eq!(
-            [160.2f64, -1.4813688f64, 0f64],
-            Venus::PRIME_MERIDIAN_COEFFICIENTS
+            (160.2f64, -1.4813688f64, 0f64, &[] as &[f64]),
+            Venus::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -544,18 +894,52 @@ mod tests {
         assert_eq!(Earth::equatorial_radius(), 6378.1366f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_399() {
+        assert_eq!(
+            (
+                &[
+                    125.045f64, 250.089f64, 260.008f64, 176.625f64, 357.529f64, 311.589f64,
+                    134.963f64, 276.617f64, 34.226f64, 15.134f64, 119.743f64, 239.961f64,
+                    25.053f64
+                ] as &[f64],
+                &[
+                    -1935.5364525f64,
+                    -3871.072905f64,
+                    475263.3328725f64,
+                    487269.629985f64,
+                    35999.0509575f64,
+                    964468.49931f64,
+                    477198.869325f64,
+                    12006.300765f64,
+                    63863.5132425f64,
+                    -5806.6093575f64,
+                    131.84064f64,
+                    6003.1503825f64,
+                    473327.79642f64
+                ] as &[f64]
+            ),
+            Earth::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_399() {
-        assert_eq!([0f64, -0.641f64, 0f64], Earth::RIGHT_ASCENSION_COEFFICIENTS)
+        assert_eq!(
+            (0f64, -0.641f64, 0f64, &[] as &[f64]),
+            Earth::right_ascension_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_399() {
-        assert_eq!([90f64, -0.557f64, 0f64], Earth::DECLINATION_COEFFICIENTS)
+        assert_eq!(
+            (90f64, -0.557f64, 0f64, &[] as &[f64]),
+            Earth::declination_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_399() {
         assert_eq!(
-            [190.147f64, 360.9856235f64, 0f64],
-            Earth::PRIME_MERIDIAN_COEFFICIENTS
+            (190.147f64, 360.9856235f64, 0f64, &[] as &[f64]),
+            Earth::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -573,109 +957,193 @@ mod tests {
         assert_eq!(Mars::equatorial_radius(), 3396.19f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_499() {
-        assert_eq!(
-            [317.269202f64, -0.10927547f64, 0f64],
-            Mars::RIGHT_ASCENSION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_declination_coefficients_499() {
-        assert_eq!(
-            [54.432516f64, -0.05827105f64, 0f64],
-            Mars::DECLINATION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_499() {
+    fn test_rotational_elements_nutation_precession_coefficients_499() {
         assert_eq!(
-            [176.049863f64, 350.891982443297f64, 0f64],
-            Mars::PRIME_MERIDIAN_COEFFICIENTS
+            (
+                &[
+                    190.72646643f64,
+                    0f64,
+                    31834.27934054f64,
+                    332.86082793f64,
+                    0f64,
+                    38280.79631835f64,
+                    189.6327156f64,
+                    12.711923222f64,
+                    660.22803474f64,
+                    231.05028581f64,
+                    0f64,
+                    1320.50145245f64,
+                    217.98635955f64,
+                    0f64,
+                    19139.83628608f64,
+                    198.991226f64,
+                    0f64,
+                    38280.8511281f64,
+                    249.663391f64,
+                    0f64,
+                    76560.636795f64,
+                    79.398797f64,
+                    0f64,
+                    19139.9407476f64,
+                    43.058401f64,
+                    0f64,
+                    57420.7517205f64,
+                    79.476401f64,
+                    0f64,
+                    0.5042615f64,
+                    129.071773f64,
+                    0f64,
+                    38281.0473591f64,
+                    56.668646f64,
+                    0f64,
+                    76560.2552215f64,
+                    104.79268f64,
+                    0f64,
+                    0.5042615f64
+                ] as &[f64],
+                &[
+                    15917.10818695f64,
+                    21.4689247f64,
+                    0f64,
+                    19139.89694742f64,
+                    394.93256437f64,
+                    0f64,
+                    41215158.1842005f64,
+                    121.46893664f64,
+                    0f64,
+                    660.9912354f64,
+                    251.37314025f64,
+                    0f64,
+                    38279.9612555f64,
+                    196.19729402f64,
+                    0f64,
+                    19139.4819985f64,
+                    226.292679f64,
+                    0f64,
+                    57420.7251593f64,
+                    266.18351f64,
+                    0f64,
+                    0.5042615f64,
+                    122.433576f64,
+                    0f64,
+                    38280.8753272f64,
+                    57.663379f64,
+                    0f64,
+                    76560.6495004f64,
+                    166.325722f64,
+                    0f64,
+                    19140.0328244f64,
+                    36.352167f64,
+                    0f64,
+                    57420.929536f64,
+                    67.364003f64,
+                    0f64,
+                    95700.4387578f64,
+                    95.391654f64,
+                    0f64
+                ] as &[f64]
+            ),
+            Mars::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients499() {
+    fn test_rotational_elements_right_ascension_coefficients_499() {
         assert_eq!(
-            &[
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0.000068f64,
-                0.000238f64,
-                0.000052f64,
-                0.000009f64,
-                0.419057f64
-            ],
-            Mars::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                317.269202f64,
+                -0.10927547f64,
+                0f64,
+                &[
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0.000068f64,
+                    0.000238f64,
+                    0.000052f64,
+                    0.000009f64,
+                    0.419057f64
+                ] as &[f64]
+            ),
+            Mars::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients499() {
+    fn test_rotational_elements_declination_coefficients_499() {
         assert_eq!(
-            &[
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0.000051f64,
-                0.000141f64,
-                0.000031f64,
-                0.000005f64,
-                1.591274f64
-            ],
-            Mars::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                54.432516f64,
+                -0.05827105f64,
+                0f64,
+                &[
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0.000051f64,
+                    0.000141f64,
+                    0.000031f64,
+                    0.000005f64,
+                    1.591274f64
+                ] as &[f64]
+            ),
+            Mars::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients499() {
+    fn test_rotational_elements_prime_meridian_coefficients_499() {
         assert_eq!(
-            &[
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0.000145f64,
-                0.000157f64,
-                0.00004f64,
-                0.000001f64,
-                0.000001f64,
-                0.584542f64
-            ],
-            Mars::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                176.049863f64,
+                350.891982443297f64,
+                0f64,
+                &[
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0.000145f64,
+                    0.000157f64,
+                    0.00004f64,
+                    0.000001f64,
+                    0.000001f64,
+                    0.584542f64
+                ] as &[f64]
+            ),
+            Mars::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -693,80 +1161,116 @@ mod tests {
         assert_eq!(Jupiter::equatorial_radius(), 71492f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_599() {
-        assert_eq!(
-            [268.056595f64, -0.006499f64, 0f64],
-            Jupiter::RIGHT_ASCENSION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_declination_coefficients_599() {
+    fn test_rotational_elements_nutation_precession_coefficients_599() {
         assert_eq!(
-            [64.495303f64, 0.002413f64, 0f64],
-            Jupiter::DECLINATION_COEFFICIENTS
+            (
+                &[
+                    73.32f64,
+                    24.62f64,
+                    283.9f64,
+                    355.8f64,
+                    119.9f64,
+                    229.8f64,
+                    352.25f64,
+                    113.35f64,
+                    146.64f64,
+                    49.24f64,
+                    99.360714f64,
+                    175.895369f64,
+                    300.323162f64,
+                    114.012305f64,
+                    49.511251f64
+                ] as &[f64],
+                &[
+                    91472.9f64,
+                    45137.2f64,
+                    4850.7f64,
+                    1191.3f64,
+                    262.1f64,
+                    64.3f64,
+                    2382.6f64,
+                    6070f64,
+                    182945.8f64,
+                    90274.4f64,
+                    4850.4046f64,
+                    1191.9605f64,
+                    262.5475f64,
+                    6070.2476f64,
+                    64.3f64
+                ] as &[f64]
+            ),
+            Jupiter::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_599() {
-        assert_eq!(
-            [284.95f64, 870.536f64, 0f64],
-            Jupiter::PRIME_MERIDIAN_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients599() {
+    fn test_rotational_elements_right_ascension_coefficients_599() {
         assert_eq!(
-            &[
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0.000117f64,
-                0.000938f64,
-                0.001432f64,
-                0.00003f64,
-                0.00215f64
-            ],
-            Jupiter::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                268.056595f64,
+                -0.006499f64,
+                0f64,
+                &[
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0.000117f64,
+                    0.000938f64,
+                    0.001432f64,
+                    0.00003f64,
+                    0.00215f64
+                ] as &[f64]
+            ),
+            Jupiter::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients599() {
+    fn test_rotational_elements_declination_coefficients_599() {
         assert_eq!(
-            &[
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                0.00005f64,
-                0.000404f64,
-                0.000617f64,
-                -0.000013f64,
-                0.000926f64
-            ],
-            Jupiter::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                64.495303f64,
+                0.002413f64,
+                0f64,
+                &[
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0.00005f64,
+                    0.000404f64,
+                    0.000617f64,
+                    -0.000013f64,
+                    0.000926f64
+                ] as &[f64]
+            ),
+            Jupiter::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients599() {
+    fn test_rotational_elements_prime_meridian_coefficients_599() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64
-            ],
-            Jupiter::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                284.95f64,
+                870.536f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64
+                ] as &[f64]
+            ),
+            Jupiter::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -784,24 +1288,44 @@ mod tests {
         assert_eq!(Saturn::equatorial_radius(), 60268f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_699() {
+        assert_eq!(
+            (
+                &[353.32f64, 28.72f64, 177.4f64, 300f64, 316.45f64, 345.2f64, 706.64f64, 57.44f64]
+                    as &[f64],
+                &[
+                    75706.7f64,
+                    75706.7f64,
+                    -36505.5f64,
+                    -7225.9f64,
+                    506.2f64,
+                    -1016.3f64,
+                    151413.4f64,
+                    151413.4f64
+                ] as &[f64]
+            ),
+            Saturn::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_699() {
         assert_eq!(
-            [40.589f64, -0.036f64, 0f64],
-            Saturn::RIGHT_ASCENSION_COEFFICIENTS
+            (40.589f64, -0.036f64, 0f64, &[] as &[f64]),
+            Saturn::right_ascension_coefficients()
         )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_699() {
         assert_eq!(
-            [83.537f64, -0.004f64, 0f64],
-            Saturn::DECLINATION_COEFFICIENTS
+            (83.537f64, -0.004f64, 0f64, &[] as &[f64]),
+            Saturn::declination_coefficients()
         )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_699() {
         assert_eq!(
-            [38.9f64, 810.7939024f64, 0f64],
-            Saturn::PRIME_MERIDIAN_COEFFICIENTS
+            (38.9f64, 810.7939024f64, 0f64, &[] as &[f64]),
+            Saturn::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -819,21 +1343,57 @@ mod tests {
         assert_eq!(Uranus::equatorial_radius(), 25559f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_799() {
+        assert_eq!(
+            (
+                &[
+                    115.75f64, 141.69f64, 135.03f64, 61.77f64, 249.32f64, 43.86f64, 77.66f64,
+                    157.36f64, 101.81f64, 138.64f64, 102.23f64, 316.41f64, 304.01f64, 308.71f64,
+                    340.82f64, 259.14f64, 204.46f64, 632.82f64
+                ] as &[f64],
+                &[
+                    54991.87f64,
+                    41887.66f64,
+                    29927.35f64,
+                    25733.59f64,
+                    24471.46f64,
+                    22278.41f64,
+                    20289.42f64,
+                    16652.76f64,
+                    12872.63f64,
+                    8061.81f64,
+                    -2024.22f64,
+                    2863.96f64,
+                    -51.94f64,
+                    -93.17f64,
+                    -75.32f64,
+                    -504.81f64,
+                    -4048.44f64,
+                    5727.92f64
+                ] as &[f64]
+            ),
+            Uranus::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_799() {
         assert_eq!(
-            [257.311f64, 0f64, 0f64],
-            Uranus::RIGHT_ASCENSION_COEFFICIENTS
+            (257.311f64, 0f64, 0f64, &[] as &[f64]),
+            Uranus::right_ascension_coefficients()
         )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_799() {
-        assert_eq!([-15.175f64, 0f64, 0f64], Uranus::DECLINATION_COEFFICIENTS)
+        assert_eq!(
+            (-15.175f64, 0f64, 0f64, &[] as &[f64]),
+            Uranus::declination_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_799() {
         assert_eq!(
-            [203.81f64, -501.1600928f64, 0f64],
-            Uranus::PRIME_MERIDIAN_COEFFICIENTS
+            (203.81f64, -501.1600928f64, 0f64, &[] as &[f64]),
+            Uranus::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -851,42 +1411,71 @@ mod tests {
         assert_eq!(Neptune::equatorial_radius(), 24764f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_899() {
-        assert_eq!(
-            [299.36f64, 0f64, 0f64],
-            Neptune::RIGHT_ASCENSION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_declination_coefficients_899() {
-        assert_eq!([43.46f64, 0f64, 0f64], Neptune::DECLINATION_COEFFICIENTS)
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_899() {
+    fn test_rotational_elements_nutation_precession_coefficients_899() {
         assert_eq!(
-            [249.978f64, 541.1397757f64, 0f64],
-            Neptune::PRIME_MERIDIAN_COEFFICIENTS
+            (
+                &[
+                    357.85f64, 323.92f64, 220.51f64, 354.27f64, 75.31f64, 35.36f64, 142.61f64,
+                    177.85f64, 647.84f64, 355.7f64, 533.55f64, 711.4f64, 889.25f64, 1067.1f64,
+                    1244.95f64, 1422.8f64, 1600.65f64
+                ] as &[f64],
+                &[
+                    52.316f64,
+                    62606.6f64,
+                    55064.2f64,
+                    46564.5f64,
+                    26109.4f64,
+                    14325.4f64,
+                    2824.6f64,
+                    52.316f64,
+                    125213.2f64,
+                    104.632f64,
+                    156.948f64,
+                    209.264f64,
+                    261.58f64,
+                    313.896f64,
+                    366.212f64,
+                    418.528f64,
+                    470.844f64
+                ] as &[f64]
+            ),
+            Neptune::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients899() {
+    fn test_rotational_elements_right_ascension_coefficients_899() {
         assert_eq!(
-            &[0.7f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64],
-            Neptune::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                299.36f64,
+                0f64,
+                0f64,
+                &[0.7f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64]
+            ),
+            Neptune::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients899() {
+    fn test_rotational_elements_declination_coefficients_899() {
         assert_eq!(
-            &[-0.51f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64],
-            Neptune::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                43.46f64,
+                0f64,
+                0f64,
+                &[-0.51f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64]
+            ),
+            Neptune::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients899() {
+    fn test_rotational_elements_prime_meridian_coefficients_899() {
         assert_eq!(
-            &[-0.48f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64],
-            Neptune::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                249.978f64,
+                541.1397757f64,
+                0f64,
+                &[-0.48f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64]
+            ),
+            Neptune::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -904,21 +1493,31 @@ mod tests {
         assert_eq!(Pluto::equatorial_radius(), 1188.3f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_999() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Pluto::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_999() {
         assert_eq!(
-            [132.993f64, 0f64, 0f64],
-            Pluto::RIGHT_ASCENSION_COEFFICIENTS
+            (132.993f64, 0f64, 0f64, &[] as &[f64]),
+            Pluto::right_ascension_coefficients()
         )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_999() {
-        assert_eq!([-6.163f64, 0f64, 0f64], Pluto::DECLINATION_COEFFICIENTS)
+        assert_eq!(
+            (-6.163f64, 0f64, 0f64, &[] as &[f64]),
+            Pluto::declination_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_999() {
         assert_eq!(
-            [302.695f64, 56.3625225f64, 0f64],
-            Pluto::PRIME_MERIDIAN_COEFFICIENTS
+            (302.695f64, 56.3625225f64, 0f64, &[] as &[f64]),
+            Pluto::prime_meridian_coefficients()
         )
     }
 }
diff --git a/crates/lox_core/src/bodies/satellites.rs b/crates/lox_core/src/bodies/satellites.rs
index 5034723e..9863c255 100644
--- a/crates/lox_core/src/bodies/satellites.rs
+++ b/crates/lox_core/src/bodies/satellites.rs
@@ -9,8 +9,8 @@
 // Auto-generated by `lox_gen`. Do not edit!
 
 use super::{
-    BodyRotationalElements, BodyTrigRotationalElements, Ellipsoid, NaifId, PointMass,
-    PolynomialCoefficient, TriAxial,
+    Ellipsoid, NaifId, NutationPrecessionCoefficients, PointMass, PolynomialCoefficients,
+    RotationalElements, TriAxial,
 };
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Moon;
@@ -41,26 +41,43 @@ impl TriAxial for Moon {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Moon {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [269.9949f64, 0.0031f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [66.5392f64, 0.013f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [38.3213f64, 13.17635815f64, -0.0000000000014f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Moon {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        -3.8787f64, -0.1204f64, 0.07f64, -0.0172f64, 0f64, 0.0072f64, 0f64, 0f64, 0f64, -0.0052f64,
-        0f64, 0f64, 0.0043f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        1.5419f64, 0.0239f64, -0.0278f64, 0.0068f64, 0f64, -0.0029f64, 0.0009f64, 0f64, 0f64,
-        0.0008f64, 0f64, 0f64, -0.0009f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        3.561f64, 0.1208f64, -0.0642f64, 0.0158f64, 0.0252f64, -0.0066f64, -0.0047f64, -0.0046f64,
-        0.0028f64, 0.0052f64, 0.004f64, 0.0019f64, -0.0044f64,
-    ];
+impl RotationalElements for Moon {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            269.9949f64,
+            0.0031f64,
+            0f64,
+            &[
+                -3.8787f64, -0.1204f64, 0.07f64, -0.0172f64, 0f64, 0.0072f64, 0f64, 0f64, 0f64,
+                -0.0052f64, 0f64, 0f64, 0.0043f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            66.5392f64,
+            0.013f64,
+            0f64,
+            &[
+                1.5419f64, 0.0239f64, -0.0278f64, 0.0068f64, 0f64, -0.0029f64, 0.0009f64, 0f64,
+                0f64, 0.0008f64, 0f64, 0f64, -0.0009f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            38.3213f64,
+            13.17635815f64,
+            -0.0000000000014f64,
+            &[
+                3.561f64, 0.1208f64, -0.0642f64, 0.0158f64, 0.0252f64, -0.0066f64, -0.0047f64,
+                -0.0046f64, 0.0028f64, 0.0052f64, 0.004f64, 0.0019f64, -0.0044f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Phobos;
@@ -91,34 +108,45 @@ impl TriAxial for Phobos {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Phobos {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [317.67071657f64, -0.10844326f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [52.88627266f64, -0.06134706f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = [
-        35.1877444f64,
-        1128.84475928f64,
-        0.000000009536137031212154f64,
-    ];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Phobos {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        -1.78428399f64,
-        0.02212824f64,
-        -0.01028251f64,
-        -0.00475595f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[-1.07516537f64, 0.00668626f64, -0.0064874f64, 0.00281576f64];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        1.42421769f64,
-        -0.02273783f64,
-        0.00410711f64,
-        0.00631964f64,
-        -1.143f64,
-    ];
+impl RotationalElements for Phobos {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            317.67071657f64,
+            -0.10844326f64,
+            0f64,
+            &[
+                -1.78428399f64,
+                0.02212824f64,
+                -0.01028251f64,
+                -0.00475595f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            52.88627266f64,
+            -0.06134706f64,
+            0f64,
+            &[-1.07516537f64, 0.00668626f64, -0.0064874f64, 0.00281576f64] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            35.1877444f64,
+            1128.84475928f64,
+            0.000000009536137031212154f64,
+            &[
+                1.42421769f64,
+                -0.02273783f64,
+                0.00410711f64,
+                0.00631964f64,
+                -1.143f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Deimos;
@@ -149,52 +177,67 @@ impl TriAxial for Deimos {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Deimos {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [316.65705808f64, -0.10518014f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [53.50992033f64, -0.05979094f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [79.39932954f64, 285.16188899f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Deimos {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        3.09217726f64,
-        0.22980637f64,
-        0.06418655f64,
-        0.02533537f64,
-        0.00778695f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        1.83936004f64,
-        0.1432532f64,
-        0.01911409f64,
-        -0.0148259f64,
-        0.0019243f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        0f64,
-        -2.73954829f64,
-        -0.39968606f64,
-        -0.06563259f64,
-        -0.0291294f64,
-        0.0169916f64,
-    ];
+impl RotationalElements for Deimos {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            316.65705808f64,
+            -0.10518014f64,
+            0f64,
+            &[
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                3.09217726f64,
+                0.22980637f64,
+                0.06418655f64,
+                0.02533537f64,
+                0.00778695f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            53.50992033f64,
+            -0.05979094f64,
+            0f64,
+            &[
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                1.83936004f64,
+                0.1432532f64,
+                0.01911409f64,
+                -0.0148259f64,
+                0.0019243f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            79.39932954f64,
+            285.16188899f64,
+            0f64,
+            &[
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                0f64,
+                -2.73954829f64,
+                -0.39968606f64,
+                -0.06563259f64,
+                -0.0291294f64,
+                0.0169916f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Io;
@@ -225,20 +268,34 @@ impl TriAxial for Io {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Io {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [268.05f64, -0.009f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [64.5f64, 0.003f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [200.39f64, 203.4889538f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Io {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0.094f64, 0.024f64];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0.04f64, 0.011f64];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, -0.085f64, -0.022f64];
+impl RotationalElements for Io {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            268.05f64,
+            -0.009f64,
+            0f64,
+            &[0f64, 0f64, 0.094f64, 0.024f64] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            64.5f64,
+            0.003f64,
+            0f64,
+            &[0f64, 0f64, 0.04f64, 0.011f64] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            200.39f64,
+            203.4889538f64,
+            0f64,
+            &[0f64, 0f64, -0.085f64, -0.022f64] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Europa;
@@ -269,20 +326,34 @@ impl TriAxial for Europa {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Europa {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [268.08f64, -0.009f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [64.51f64, 0.003f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [36.022f64, 101.3747235f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Europa {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, 1.086f64, 0.06f64, 0.015f64, 0.009f64];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, 0.468f64, 0.026f64, 0.007f64, 0.002f64];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, -0.98f64, -0.054f64, -0.014f64, -0.008f64];
+impl RotationalElements for Europa {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            268.08f64,
+            -0.009f64,
+            0f64,
+            &[0f64, 0f64, 0f64, 1.086f64, 0.06f64, 0.015f64, 0.009f64] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            64.51f64,
+            0.003f64,
+            0f64,
+            &[0f64, 0f64, 0f64, 0.468f64, 0.026f64, 0.007f64, 0.002f64] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            36.022f64,
+            101.3747235f64,
+            0f64,
+            &[0f64, 0f64, 0f64, -0.98f64, -0.054f64, -0.014f64, -0.008f64] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Ganymede;
@@ -313,20 +384,34 @@ impl TriAxial for Ganymede {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Ganymede {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [268.2f64, -0.009f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [64.57f64, 0.003f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [44.064f64, 50.3176081f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Ganymede {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, -0.037f64, 0.431f64, 0.091f64];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, -0.016f64, 0.186f64, 0.039f64];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, 0.033f64, -0.389f64, -0.082f64];
+impl RotationalElements for Ganymede {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            268.2f64,
+            -0.009f64,
+            0f64,
+            &[0f64, 0f64, 0f64, -0.037f64, 0.431f64, 0.091f64] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            64.57f64,
+            0.003f64,
+            0f64,
+            &[0f64, 0f64, 0f64, -0.016f64, 0.186f64, 0.039f64] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            44.064f64,
+            50.3176081f64,
+            0f64,
+            &[0f64, 0f64, 0f64, 0.033f64, -0.389f64, -0.082f64] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Callisto;
@@ -357,20 +442,34 @@ impl TriAxial for Callisto {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Callisto {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [268.72f64, -0.009f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [64.83f64, 0.003f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [259.51f64, 21.5710715f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Callisto {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, 0f64, -0.068f64, 0.59f64, 0f64, 0.01f64];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, 0f64, -0.029f64, 0.254f64, 0f64, -0.004f64];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, 0f64, 0.061f64, -0.533f64, 0f64, -0.009f64];
+impl RotationalElements for Callisto {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            268.72f64,
+            -0.009f64,
+            0f64,
+            &[0f64, 0f64, 0f64, 0f64, -0.068f64, 0.59f64, 0f64, 0.01f64] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            64.83f64,
+            0.003f64,
+            0f64,
+            &[0f64, 0f64, 0f64, 0f64, -0.029f64, 0.254f64, 0f64, -0.004f64] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            259.51f64,
+            21.5710715f64,
+            0f64,
+            &[0f64, 0f64, 0f64, 0f64, 0.061f64, -0.533f64, 0f64, -0.009f64] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Amalthea;
@@ -401,23 +500,40 @@ impl TriAxial for Amalthea {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Amalthea {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [268.05f64, -0.009f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [64.49f64, 0.003f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [231.67f64, 722.631456f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Amalthea {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        -0.84f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.01f64, 0f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        -0.36f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0.76f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.01f64, 0f64,
-    ];
+impl RotationalElements for Amalthea {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            268.05f64,
+            -0.009f64,
+            0f64,
+            &[
+                -0.84f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.01f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            64.49f64,
+            0.003f64,
+            0f64,
+            &[
+                -0.36f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            231.67f64,
+            722.631456f64,
+            0f64,
+            &[
+                0.76f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.01f64, 0f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Himalia;
@@ -447,6 +563,21 @@ impl TriAxial for Himalia {
         85f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Himalia {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Elara;
 impl NaifId for Elara {
@@ -470,6 +601,21 @@ impl TriAxial for Elara {
         40f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Elara {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Pasiphae;
 impl NaifId for Pasiphae {
@@ -493,6 +639,21 @@ impl TriAxial for Pasiphae {
         18f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Pasiphae {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Sinope;
 impl NaifId for Sinope {
@@ -516,6 +677,21 @@ impl TriAxial for Sinope {
         14f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Sinope {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Lysithea;
 impl NaifId for Lysithea {
@@ -539,6 +715,21 @@ impl TriAxial for Lysithea {
         12f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Lysithea {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Carme;
 impl NaifId for Carme {
@@ -562,6 +753,21 @@ impl TriAxial for Carme {
         15f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Carme {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Ananke;
 impl NaifId for Ananke {
@@ -585,6 +791,21 @@ impl TriAxial for Ananke {
         10f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Ananke {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Leda;
 impl NaifId for Leda {
@@ -608,6 +829,21 @@ impl TriAxial for Leda {
         5f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Leda {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Thebe;
 impl NaifId for Thebe {
@@ -637,22 +873,40 @@ impl TriAxial for Thebe {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Thebe {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [268.05f64, -0.009f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [64.49f64, 0.003f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = [8.56f64, 533.70041f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Thebe {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, -2.11f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.04f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, -0.91f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.01f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 1.91f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.04f64,
-    ];
+impl RotationalElements for Thebe {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            268.05f64,
+            -0.009f64,
+            0f64,
+            &[
+                0f64, -2.11f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.04f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            64.49f64,
+            0.003f64,
+            0f64,
+            &[
+                0f64, -0.91f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.01f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            8.56f64,
+            533.70041f64,
+            0f64,
+            &[
+                0f64, 1.91f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.04f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Adrastea;
@@ -683,11 +937,19 @@ impl TriAxial for Adrastea {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Adrastea {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [268.05f64, -0.009f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [64.49f64, 0.003f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [33.29f64, 1206.9986602f64, 0f64];
+impl RotationalElements for Adrastea {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (268.05f64, -0.009f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (64.49f64, 0.003f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (33.29f64, 1206.9986602f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Metis;
@@ -718,11 +980,19 @@ impl TriAxial for Metis {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Metis {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [268.05f64, -0.009f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [64.49f64, 0.003f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [346.09f64, 1221.2547301f64, 0f64];
+impl RotationalElements for Metis {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (268.05f64, -0.009f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (64.49f64, 0.003f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (346.09f64, 1221.2547301f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Callirrhoe;
@@ -731,6 +1001,21 @@ impl NaifId for Callirrhoe {
         517i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Callirrhoe {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Themisto;
 impl NaifId for Themisto {
@@ -738,6 +1023,21 @@ impl NaifId for Themisto {
         518i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Themisto {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Magaclite;
 impl NaifId for Magaclite {
@@ -745,6 +1045,21 @@ impl NaifId for Magaclite {
         519i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Magaclite {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Taygete;
 impl NaifId for Taygete {
@@ -752,6 +1067,21 @@ impl NaifId for Taygete {
         520i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Taygete {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Chaldene;
 impl NaifId for Chaldene {
@@ -759,6 +1089,21 @@ impl NaifId for Chaldene {
         521i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Chaldene {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Harpalyke;
 impl NaifId for Harpalyke {
@@ -766,6 +1111,21 @@ impl NaifId for Harpalyke {
         522i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Harpalyke {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Kalyke;
 impl NaifId for Kalyke {
@@ -773,6 +1133,21 @@ impl NaifId for Kalyke {
         523i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Kalyke {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Iocaste;
 impl NaifId for Iocaste {
@@ -780,6 +1155,21 @@ impl NaifId for Iocaste {
         524i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Iocaste {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Erinome;
 impl NaifId for Erinome {
@@ -787,6 +1177,21 @@ impl NaifId for Erinome {
         525i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Erinome {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Isonoe;
 impl NaifId for Isonoe {
@@ -794,6 +1199,21 @@ impl NaifId for Isonoe {
         526i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Isonoe {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Praxidike;
 impl NaifId for Praxidike {
@@ -801,6 +1221,21 @@ impl NaifId for Praxidike {
         527i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Praxidike {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Autonoe;
 impl NaifId for Autonoe {
@@ -808,6 +1243,21 @@ impl NaifId for Autonoe {
         528i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Autonoe {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Thyone;
 impl NaifId for Thyone {
@@ -815,11 +1265,41 @@ impl NaifId for Thyone {
         529i32
     }
 }
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
-pub struct Hermippe;
-impl NaifId for Hermippe {
-    fn id() -> i32 {
-        530i32
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Thyone {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub struct Hermippe;
+impl NaifId for Hermippe {
+    fn id() -> i32 {
+        530i32
+    }
+}
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Hermippe {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
     }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
@@ -829,6 +1309,21 @@ impl NaifId for Aitne {
         531i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Aitne {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Eurydome;
 impl NaifId for Eurydome {
@@ -836,6 +1331,21 @@ impl NaifId for Eurydome {
         532i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Eurydome {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Euanthe;
 impl NaifId for Euanthe {
@@ -843,6 +1353,21 @@ impl NaifId for Euanthe {
         533i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Euanthe {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Euporie;
 impl NaifId for Euporie {
@@ -850,6 +1375,21 @@ impl NaifId for Euporie {
         534i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Euporie {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Orthosie;
 impl NaifId for Orthosie {
@@ -857,6 +1397,21 @@ impl NaifId for Orthosie {
         535i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Orthosie {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Sponde;
 impl NaifId for Sponde {
@@ -864,6 +1419,21 @@ impl NaifId for Sponde {
         536i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Sponde {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Kale;
 impl NaifId for Kale {
@@ -871,6 +1441,21 @@ impl NaifId for Kale {
         537i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Kale {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Pasithee;
 impl NaifId for Pasithee {
@@ -878,6 +1463,21 @@ impl NaifId for Pasithee {
         538i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Pasithee {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Hegemone;
 impl NaifId for Hegemone {
@@ -885,6 +1485,21 @@ impl NaifId for Hegemone {
         539i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Hegemone {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Mneme;
 impl NaifId for Mneme {
@@ -892,6 +1507,21 @@ impl NaifId for Mneme {
         540i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Mneme {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Aoede;
 impl NaifId for Aoede {
@@ -899,6 +1529,21 @@ impl NaifId for Aoede {
         541i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Aoede {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Thelxinoe;
 impl NaifId for Thelxinoe {
@@ -906,6 +1551,21 @@ impl NaifId for Thelxinoe {
         542i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Thelxinoe {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Arche;
 impl NaifId for Arche {
@@ -913,6 +1573,21 @@ impl NaifId for Arche {
         543i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Arche {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Kallichore;
 impl NaifId for Kallichore {
@@ -920,6 +1595,21 @@ impl NaifId for Kallichore {
         544i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Kallichore {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Helike;
 impl NaifId for Helike {
@@ -927,6 +1617,21 @@ impl NaifId for Helike {
         545i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Helike {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Carpo;
 impl NaifId for Carpo {
@@ -934,6 +1639,21 @@ impl NaifId for Carpo {
         546i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Carpo {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Eukelade;
 impl NaifId for Eukelade {
@@ -941,6 +1661,21 @@ impl NaifId for Eukelade {
         547i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Eukelade {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Cyllene;
 impl NaifId for Cyllene {
@@ -948,6 +1683,21 @@ impl NaifId for Cyllene {
         548i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Cyllene {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Kore;
 impl NaifId for Kore {
@@ -955,6 +1705,21 @@ impl NaifId for Kore {
         549i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Kore {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Herse;
 impl NaifId for Herse {
@@ -962,6 +1727,21 @@ impl NaifId for Herse {
         550i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Herse {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Dia;
 impl NaifId for Dia {
@@ -969,6 +1749,21 @@ impl NaifId for Dia {
         553i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Dia {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Mimas;
 impl NaifId for Mimas {
@@ -998,20 +1793,34 @@ impl TriAxial for Mimas {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Mimas {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [40.66f64, -0.036f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [83.52f64, -0.004f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [333.46f64, 381.994555f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Mimas {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 13.56f64, 0f64, 0f64, 0f64, 0f64, 0f64];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, -1.53f64, 0f64, 0f64, 0f64, 0f64, 0f64];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, -13.48f64, 0f64, -44.85f64, 0f64, 0f64, 0f64];
+impl RotationalElements for Mimas {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            40.66f64,
+            -0.036f64,
+            0f64,
+            &[0f64, 0f64, 13.56f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            83.52f64,
+            -0.004f64,
+            0f64,
+            &[0f64, 0f64, -1.53f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            333.46f64,
+            381.994555f64,
+            0f64,
+            &[0f64, 0f64, -13.48f64, 0f64, -44.85f64, 0f64, 0f64, 0f64] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Enceladus;
@@ -1042,10 +1851,19 @@ impl TriAxial for Enceladus {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Enceladus {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [40.66f64, -0.036f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [83.52f64, -0.004f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = [6.32f64, 262.7318996f64, 0f64];
+impl RotationalElements for Enceladus {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (40.66f64, -0.036f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (83.52f64, -0.004f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (6.32f64, 262.7318996f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Tethys;
@@ -1076,19 +1894,34 @@ impl TriAxial for Tethys {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Tethys {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [40.66f64, -0.036f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [83.52f64, -0.004f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = [8.95f64, 190.6979085f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Tethys {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, 9.66f64, 0f64, 0f64, 0f64, 0f64];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, -1.09f64, 0f64, 0f64, 0f64, 0f64];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, -9.6f64, 2.23f64, 0f64, 0f64, 0f64];
+impl RotationalElements for Tethys {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            40.66f64,
+            -0.036f64,
+            0f64,
+            &[0f64, 0f64, 0f64, 9.66f64, 0f64, 0f64, 0f64, 0f64] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            83.52f64,
+            -0.004f64,
+            0f64,
+            &[0f64, 0f64, 0f64, -1.09f64, 0f64, 0f64, 0f64, 0f64] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            8.95f64,
+            190.6979085f64,
+            0f64,
+            &[0f64, 0f64, 0f64, -9.6f64, 2.23f64, 0f64, 0f64, 0f64] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Dione;
@@ -1119,11 +1952,19 @@ impl TriAxial for Dione {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Dione {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [40.66f64, -0.036f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [83.52f64, -0.004f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [357.6f64, 131.5349316f64, 0f64];
+impl RotationalElements for Dione {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (40.66f64, -0.036f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (83.52f64, -0.004f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (357.6f64, 131.5349316f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Rhea;
@@ -1154,20 +1995,34 @@ impl TriAxial for Rhea {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Rhea {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [40.38f64, -0.036f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [83.55f64, -0.004f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [235.16f64, 79.6900478f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Rhea {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, 0f64, 0f64, 3.1f64, 0f64, 0f64];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, 0f64, 0f64, -0.35f64, 0f64, 0f64];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, 0f64, 0f64, -3.08f64, 0f64, 0f64];
+impl RotationalElements for Rhea {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            40.38f64,
+            -0.036f64,
+            0f64,
+            &[0f64, 0f64, 0f64, 0f64, 0f64, 3.1f64, 0f64, 0f64] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            83.55f64,
+            -0.004f64,
+            0f64,
+            &[0f64, 0f64, 0f64, 0f64, 0f64, -0.35f64, 0f64, 0f64] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            235.16f64,
+            79.6900478f64,
+            0f64,
+            &[0f64, 0f64, 0f64, 0f64, 0f64, -3.08f64, 0f64, 0f64] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Titan;
@@ -1198,20 +2053,34 @@ impl TriAxial for Titan {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Titan {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [39.4827f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [83.4279f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [186.5855f64, 22.5769768f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Titan {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64];
+impl RotationalElements for Titan {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            39.4827f64,
+            0f64,
+            0f64,
+            &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            83.4279f64,
+            0f64,
+            0f64,
+            &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            186.5855f64,
+            22.5769768f64,
+            0f64,
+            &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Hyperion;
@@ -1241,6 +2110,21 @@ impl TriAxial for Hyperion {
         133f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Hyperion {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Iapetus;
 impl NaifId for Iapetus {
@@ -1270,10 +2154,19 @@ impl TriAxial for Iapetus {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Iapetus {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [318.16f64, -3.949f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [75.03f64, -1.143f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = [355.2f64, 4.5379572f64, 0f64];
+impl RotationalElements for Iapetus {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (318.16f64, -3.949f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (75.03f64, -1.143f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (355.2f64, 4.5379572f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Phoebe;
@@ -1304,10 +2197,19 @@ impl TriAxial for Phoebe {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Phoebe {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [356.9f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [77.8f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = [178.58f64, 931.639f64, 0f64];
+impl RotationalElements for Phoebe {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (356.9f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (77.8f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (178.58f64, 931.639f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Janus;
@@ -1338,20 +2240,34 @@ impl TriAxial for Janus {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Janus {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [40.58f64, -0.036f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [83.52f64, -0.004f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [58.83f64, 518.2359876f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Janus {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, -1.623f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.023f64];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, -0.183f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.001f64];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[0f64, 1.613f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.023f64];
+impl RotationalElements for Janus {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            40.58f64,
+            -0.036f64,
+            0f64,
+            &[0f64, -1.623f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.023f64] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            83.52f64,
+            -0.004f64,
+            0f64,
+            &[0f64, -0.183f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.001f64] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            58.83f64,
+            518.2359876f64,
+            0f64,
+            &[0f64, 1.613f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.023f64] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Epimetheus;
@@ -1382,20 +2298,34 @@ impl TriAxial for Epimetheus {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Epimetheus {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [40.58f64, -0.036f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [83.52f64, -0.004f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [293.87f64, 518.4907239f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Epimetheus {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[-3.153f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.086f64, 0f64];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[-0.356f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.005f64, 0f64];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] =
-        &[3.133f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.086f64, 0f64];
+impl RotationalElements for Epimetheus {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            40.58f64,
+            -0.036f64,
+            0f64,
+            &[-3.153f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.086f64, 0f64] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            83.52f64,
+            -0.004f64,
+            0f64,
+            &[-0.356f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.005f64, 0f64] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            293.87f64,
+            518.4907239f64,
+            0f64,
+            &[3.133f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.086f64, 0f64] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Helene;
@@ -1426,11 +2356,19 @@ impl TriAxial for Helene {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Helene {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [40.85f64, -0.036f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [83.34f64, -0.004f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [245.12f64, 131.6174056f64, 0f64];
+impl RotationalElements for Helene {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (40.85f64, -0.036f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (83.34f64, -0.004f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (245.12f64, 131.6174056f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Telesto;
@@ -1456,11 +2394,19 @@ impl TriAxial for Telesto {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Telesto {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [50.51f64, -0.036f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [84.06f64, -0.004f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [56.88f64, 190.6979332f64, 0f64];
+impl RotationalElements for Telesto {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (50.51f64, -0.036f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (84.06f64, -0.004f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (56.88f64, 190.6979332f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Calypso;
@@ -1486,11 +2432,19 @@ impl TriAxial for Calypso {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Calypso {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [36.41f64, -0.036f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [85.04f64, -0.004f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [153.51f64, 190.6742373f64, 0f64];
+impl RotationalElements for Calypso {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (36.41f64, -0.036f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (85.04f64, -0.004f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (153.51f64, 190.6742373f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Atlas;
@@ -1521,10 +2475,19 @@ impl TriAxial for Atlas {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Atlas {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [40.58f64, -0.036f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [83.53f64, -0.004f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = [137.88f64, 598.306f64, 0f64];
+impl RotationalElements for Atlas {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (40.58f64, -0.036f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (83.53f64, -0.004f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (137.88f64, 598.306f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Prometheus;
@@ -1555,10 +2518,19 @@ impl TriAxial for Prometheus {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Prometheus {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [40.58f64, -0.036f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [83.53f64, -0.004f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = [296.14f64, 587.289f64, 0f64];
+impl RotationalElements for Prometheus {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (40.58f64, -0.036f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (83.53f64, -0.004f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (296.14f64, 587.289f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Pandora;
@@ -1589,10 +2561,19 @@ impl TriAxial for Pandora {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Pandora {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [40.58f64, -0.036f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [83.53f64, -0.004f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = [162.92f64, 572.7891f64, 0f64];
+impl RotationalElements for Pandora {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (40.58f64, -0.036f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (83.53f64, -0.004f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (162.92f64, 572.7891f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Pan;
@@ -1618,10 +2599,19 @@ impl TriAxial for Pan {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Pan {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [40.6f64, -0.036f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [83.5f64, -0.004f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = [48.8f64, 626.044f64, 0f64];
+impl RotationalElements for Pan {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (40.6f64, -0.036f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (83.5f64, -0.004f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (48.8f64, 626.044f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Ymir;
@@ -1630,6 +2620,21 @@ impl NaifId for Ymir {
         619i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Ymir {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Paaliaq;
 impl NaifId for Paaliaq {
@@ -1637,13 +2642,43 @@ impl NaifId for Paaliaq {
         620i32
     }
 }
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
-pub struct Tarvos;
-impl NaifId for Tarvos {
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Paaliaq {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub struct Tarvos;
+impl NaifId for Tarvos {
     fn id() -> i32 {
         621i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Tarvos {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Ijiraq;
 impl NaifId for Ijiraq {
@@ -1651,6 +2686,21 @@ impl NaifId for Ijiraq {
         622i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Ijiraq {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Suttungr;
 impl NaifId for Suttungr {
@@ -1658,6 +2708,21 @@ impl NaifId for Suttungr {
         623i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Suttungr {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Kiviuq;
 impl NaifId for Kiviuq {
@@ -1665,6 +2730,21 @@ impl NaifId for Kiviuq {
         624i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Kiviuq {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Mundilfari;
 impl NaifId for Mundilfari {
@@ -1672,6 +2752,21 @@ impl NaifId for Mundilfari {
         625i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Mundilfari {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Albiorix;
 impl NaifId for Albiorix {
@@ -1679,6 +2774,21 @@ impl NaifId for Albiorix {
         626i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Albiorix {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Skathi;
 impl NaifId for Skathi {
@@ -1686,6 +2796,21 @@ impl NaifId for Skathi {
         627i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Skathi {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Erriapus;
 impl NaifId for Erriapus {
@@ -1693,6 +2818,21 @@ impl NaifId for Erriapus {
         628i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Erriapus {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Siarnaq;
 impl NaifId for Siarnaq {
@@ -1700,6 +2840,21 @@ impl NaifId for Siarnaq {
         629i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Siarnaq {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Thrymr;
 impl NaifId for Thrymr {
@@ -1707,6 +2862,21 @@ impl NaifId for Thrymr {
         630i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Thrymr {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Narvi;
 impl NaifId for Narvi {
@@ -1714,6 +2884,21 @@ impl NaifId for Narvi {
         631i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Narvi {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Methone;
 impl NaifId for Methone {
@@ -1737,6 +2922,21 @@ impl TriAxial for Methone {
         1.29f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Methone {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Pallene;
 impl NaifId for Pallene {
@@ -1760,6 +2960,21 @@ impl TriAxial for Pallene {
         2.08f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Pallene {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Polydeuces;
 impl NaifId for Polydeuces {
@@ -1783,6 +2998,21 @@ impl TriAxial for Polydeuces {
         1.2f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Polydeuces {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Daphnis;
 impl NaifId for Daphnis {
@@ -1806,6 +3036,21 @@ impl TriAxial for Daphnis {
         4.5f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Daphnis {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Aegir;
 impl NaifId for Aegir {
@@ -1813,6 +3058,21 @@ impl NaifId for Aegir {
         636i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Aegir {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Bebhionn;
 impl NaifId for Bebhionn {
@@ -1820,6 +3080,21 @@ impl NaifId for Bebhionn {
         637i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Bebhionn {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Bergelmir;
 impl NaifId for Bergelmir {
@@ -1827,6 +3102,21 @@ impl NaifId for Bergelmir {
         638i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Bergelmir {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Bestla;
 impl NaifId for Bestla {
@@ -1834,6 +3124,21 @@ impl NaifId for Bestla {
         639i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Bestla {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Farbauti;
 impl NaifId for Farbauti {
@@ -1841,6 +3146,21 @@ impl NaifId for Farbauti {
         640i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Farbauti {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Fenrir;
 impl NaifId for Fenrir {
@@ -1848,6 +3168,21 @@ impl NaifId for Fenrir {
         641i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Fenrir {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Fornjot;
 impl NaifId for Fornjot {
@@ -1855,6 +3190,21 @@ impl NaifId for Fornjot {
         642i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Fornjot {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Hati;
 impl NaifId for Hati {
@@ -1862,6 +3212,21 @@ impl NaifId for Hati {
         643i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Hati {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Hyrrokkin;
 impl NaifId for Hyrrokkin {
@@ -1869,6 +3234,21 @@ impl NaifId for Hyrrokkin {
         644i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Hyrrokkin {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Kari;
 impl NaifId for Kari {
@@ -1876,6 +3256,21 @@ impl NaifId for Kari {
         645i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Kari {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Loge;
 impl NaifId for Loge {
@@ -1883,6 +3278,21 @@ impl NaifId for Loge {
         646i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Loge {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Skoll;
 impl NaifId for Skoll {
@@ -1890,6 +3300,21 @@ impl NaifId for Skoll {
         647i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Skoll {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Surtur;
 impl NaifId for Surtur {
@@ -1897,6 +3322,21 @@ impl NaifId for Surtur {
         648i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Surtur {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Anthe;
 impl NaifId for Anthe {
@@ -1920,6 +3360,21 @@ impl TriAxial for Anthe {
         0.5f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Anthe {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Jarnsaxa;
 impl NaifId for Jarnsaxa {
@@ -1927,6 +3382,21 @@ impl NaifId for Jarnsaxa {
         650i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Jarnsaxa {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Greip;
 impl NaifId for Greip {
@@ -1934,6 +3404,21 @@ impl NaifId for Greip {
         651i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Greip {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Tarqeq;
 impl NaifId for Tarqeq {
@@ -1941,6 +3426,21 @@ impl NaifId for Tarqeq {
         652i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Tarqeq {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Aegaeon;
 impl NaifId for Aegaeon {
@@ -1964,6 +3464,21 @@ impl TriAxial for Aegaeon {
         0.25f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Aegaeon {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Ariel;
 impl NaifId for Ariel {
@@ -1993,23 +3508,40 @@ impl TriAxial for Ariel {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Ariel {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [257.43f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-15.1f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [156.22f64, -142.8356681f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Ariel {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.29f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.28f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.05f64, 0.08f64,
-    ];
+impl RotationalElements for Ariel {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            257.43f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.29f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            -15.1f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.28f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            156.22f64,
+            -142.8356681f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.05f64, 0.08f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Umbriel;
@@ -2040,23 +3572,43 @@ impl TriAxial for Umbriel {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Umbriel {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [257.43f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-15.1f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [108.05f64, -86.8688923f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Umbriel {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.21f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.2f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.09f64, 0f64, 0.06f64,
-    ];
+impl RotationalElements for Umbriel {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            257.43f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0.21f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            -15.1f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0.2f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            108.05f64,
+            -86.8688923f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.09f64, 0f64,
+                0.06f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Titania;
@@ -2087,23 +3639,43 @@ impl TriAxial for Titania {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Titania {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [257.43f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-15.1f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [77.74f64, -41.3514316f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Titania {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.29f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.28f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.08f64,
-    ];
+impl RotationalElements for Titania {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            257.43f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0.29f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            -15.1f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0.28f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            77.74f64,
+            -41.3514316f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0.08f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Oberon;
@@ -2134,33 +3706,51 @@ impl TriAxial for Oberon {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Oberon {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [257.43f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-15.1f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = [6.77f64, -26.7394932f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Oberon {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0.16f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0.16f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0.04f64,
-    ];
-}
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
-pub struct Miranda;
-impl NaifId for Miranda {
-    fn id() -> i32 {
-        705i32
-    }
-}
+impl RotationalElements for Oberon {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            257.43f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0.16f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            -15.1f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0.16f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            6.77f64,
+            -26.7394932f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0.04f64,
+            ] as &[f64],
+        )
+    }
+}
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub struct Miranda;
+impl NaifId for Miranda {
+    fn id() -> i32 {
+        705i32
+    }
+}
 impl PointMass for Miranda {
     fn gravitational_parameter() -> f64 {
         4.3195168992321f64
@@ -2183,26 +3773,43 @@ impl TriAxial for Miranda {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Miranda {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [257.43f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-15.08f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [30.7f64, -254.6906892f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Miranda {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 4.41f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, -0.04f64, 0f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 4.25f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, -0.02f64, 0f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 1.15f64, -1.27f64, 0f64, 0f64,
-        0f64, 0f64, -0.09f64, 0.15f64,
-    ];
+impl RotationalElements for Miranda {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            257.43f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 4.41f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, -0.04f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            -15.08f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 4.25f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, -0.02f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            30.7f64,
+            -254.6906892f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 1.15f64, -1.27f64,
+                0f64, 0f64, 0f64, 0f64, -0.09f64, 0.15f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Cordelia;
@@ -2228,26 +3835,43 @@ impl TriAxial for Cordelia {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Cordelia {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [257.31f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-15.18f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [127.69f64, -1074.520573f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Cordelia {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        -0.15f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0.14f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
+impl RotationalElements for Cordelia {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            257.31f64,
+            0f64,
+            0f64,
+            &[
+                -0.15f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            -15.18f64,
+            0f64,
+            0f64,
+            &[
+                0.14f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            127.69f64,
+            -1074.520573f64,
+            0f64,
+            &[
+                -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Ophelia;
@@ -2273,26 +3897,43 @@ impl TriAxial for Ophelia {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Ophelia {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [257.31f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-15.18f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [130.35f64, -956.406815f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Ophelia {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, -0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, -0.03f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
+impl RotationalElements for Ophelia {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            257.31f64,
+            0f64,
+            0f64,
+            &[
+                0f64, -0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            -15.18f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            130.35f64,
+            -956.406815f64,
+            0f64,
+            &[
+                0f64, -0.03f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Bianca;
@@ -2318,26 +3959,43 @@ impl TriAxial for Bianca {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Bianca {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [257.31f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-15.18f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [105.46f64, -828.391476f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Bianca {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, -0.16f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0.16f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
+impl RotationalElements for Bianca {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            257.31f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, -0.16f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            -15.18f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0.16f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            105.46f64,
+            -828.391476f64,
+            0f64,
+            &[
+                0f64, 0f64, -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Cressida;
@@ -2363,26 +4021,43 @@ impl TriAxial for Cressida {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Cressida {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [257.31f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-15.18f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [59.16f64, -776.581632f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Cressida {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, -0.01f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
+impl RotationalElements for Cressida {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            257.31f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            -15.18f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            59.16f64,
+            -776.581632f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, -0.01f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Desdemona;
@@ -2408,26 +4083,43 @@ impl TriAxial for Desdemona {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Desdemona {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [257.31f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-15.18f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [95.08f64, -760.053169f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Desdemona {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, -0.17f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0.16f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
+impl RotationalElements for Desdemona {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            257.31f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, -0.17f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            -15.18f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0.16f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            95.08f64,
+            -760.053169f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Juliet;
@@ -2453,26 +4145,43 @@ impl TriAxial for Juliet {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Juliet {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [257.31f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-15.18f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [302.56f64, -730.125366f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Juliet {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, -0.06f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0.06f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, -0.02f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
+impl RotationalElements for Juliet {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            257.31f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, -0.06f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            -15.18f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0.06f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            302.56f64,
+            -730.125366f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, -0.02f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Portia;
@@ -2498,26 +4207,43 @@ impl TriAxial for Portia {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Portia {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [257.31f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-15.18f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [25.03f64, -701.486587f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Portia {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.02f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
+impl RotationalElements for Portia {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            257.31f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            -15.18f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            25.03f64,
+            -701.486587f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.02f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Rosalind;
@@ -2543,26 +4269,43 @@ impl TriAxial for Rosalind {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Rosalind {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [257.31f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-15.18f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [314.9f64, -644.631126f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Rosalind {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.29f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.28f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.08f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
+impl RotationalElements for Rosalind {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            257.31f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.29f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            -15.18f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.28f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            314.9f64,
+            -644.631126f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.08f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Belinda;
@@ -2588,26 +4331,43 @@ impl TriAxial for Belinda {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Belinda {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [257.31f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-15.18f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [297.46f64, -577.362817f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Belinda {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.03f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.03f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.01f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
+impl RotationalElements for Belinda {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            257.31f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.03f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            -15.18f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.03f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            297.46f64,
+            -577.362817f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.01f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Puck;
@@ -2633,26 +4393,43 @@ impl TriAxial for Puck {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Puck {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [257.31f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-15.18f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [91.24f64, -472.545069f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Puck {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.33f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.31f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.09f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
+impl RotationalElements for Puck {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            257.31f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.33f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            -15.18f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.31f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            91.24f64,
+            -472.545069f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.09f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Caliban;
@@ -2661,6 +4438,21 @@ impl NaifId for Caliban {
         716i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Caliban {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Sycorax;
 impl NaifId for Sycorax {
@@ -2668,6 +4460,21 @@ impl NaifId for Sycorax {
         717i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Sycorax {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Prospero;
 impl NaifId for Prospero {
@@ -2675,6 +4482,21 @@ impl NaifId for Prospero {
         718i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Prospero {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Setebos;
 impl NaifId for Setebos {
@@ -2682,6 +4504,21 @@ impl NaifId for Setebos {
         719i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Setebos {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Stephano;
 impl NaifId for Stephano {
@@ -2689,6 +4526,21 @@ impl NaifId for Stephano {
         720i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Stephano {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Trinculo;
 impl NaifId for Trinculo {
@@ -2696,6 +4548,21 @@ impl NaifId for Trinculo {
         721i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Trinculo {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Francisco;
 impl NaifId for Francisco {
@@ -2703,6 +4570,21 @@ impl NaifId for Francisco {
         722i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Francisco {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Margaret;
 impl NaifId for Margaret {
@@ -2710,6 +4592,21 @@ impl NaifId for Margaret {
         723i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Margaret {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Ferdinand;
 impl NaifId for Ferdinand {
@@ -2717,6 +4614,21 @@ impl NaifId for Ferdinand {
         724i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Ferdinand {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Perdita;
 impl NaifId for Perdita {
@@ -2724,6 +4636,21 @@ impl NaifId for Perdita {
         725i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Perdita {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Mab;
 impl NaifId for Mab {
@@ -2731,6 +4658,21 @@ impl NaifId for Mab {
         726i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Mab {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Cupid;
 impl NaifId for Cupid {
@@ -2738,6 +4680,21 @@ impl NaifId for Cupid {
         727i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Cupid {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Triton;
 impl NaifId for Triton {
@@ -2767,34 +4724,51 @@ impl TriAxial for Triton {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Triton {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [299.36f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [41.17f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [296.53f64, -61.2572637f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Triton {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -32.35f64, 0f64, -6.28f64, -2.08f64, -0.74f64,
-        -0.28f64, -0.11f64, -0.07f64, -0.02f64, -0.01f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 22.55f64, 0f64, 2.1f64, 0.55f64, 0.16f64,
-        0.05f64, 0.02f64, 0.01f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 22.25f64, 0f64, 6.73f64, 2.05f64, 0.74f64,
-        0.28f64, 0.11f64, 0.05f64, 0.02f64, 0.01f64,
-    ];
-}
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
-pub struct Nereid;
-impl NaifId for Nereid {
-    fn id() -> i32 {
-        802i32
-    }
-}
+impl RotationalElements for Triton {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            299.36f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -32.35f64, 0f64, -6.28f64, -2.08f64,
+                -0.74f64, -0.28f64, -0.11f64, -0.07f64, -0.02f64, -0.01f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            41.17f64,
+            0f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 22.55f64, 0f64, 2.1f64, 0.55f64, 0.16f64,
+                0.05f64, 0.02f64, 0.01f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            296.53f64,
+            -61.2572637f64,
+            0f64,
+            &[
+                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 22.25f64, 0f64, 6.73f64, 2.05f64,
+                0.74f64, 0.28f64, 0.11f64, 0.05f64, 0.02f64, 0.01f64,
+            ] as &[f64],
+        )
+    }
+}
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub struct Nereid;
+impl NaifId for Nereid {
+    fn id() -> i32 {
+        802i32
+    }
+}
 impl Ellipsoid for Nereid {
     fn polar_radius() -> f64 {
         170f64
@@ -2811,6 +4785,21 @@ impl TriAxial for Nereid {
         170f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Nereid {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Naiad;
 impl NaifId for Naiad {
@@ -2840,26 +4829,43 @@ impl TriAxial for Naiad {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Naiad {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [299.36f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [43.36f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [254.06f64, 1222.8441209f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Naiad {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0.7f64, -6.49f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.25f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        -0.51f64, -4.75f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.09f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        -0.48f64, 4.4f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.27f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64, 0f64,
-    ];
+impl RotationalElements for Naiad {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            299.36f64,
+            0f64,
+            0f64,
+            &[
+                0.7f64, -6.49f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.25f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            43.36f64,
+            0f64,
+            0f64,
+            &[
+                -0.51f64, -4.75f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.09f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            254.06f64,
+            1222.8441209f64,
+            0f64,
+            &[
+                -0.48f64, 4.4f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.27f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Thalassa;
@@ -2890,26 +4896,43 @@ impl TriAxial for Thalassa {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Thalassa {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [299.36f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [43.45f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [102.06f64, 1155.7555612f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Thalassa {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0.7f64, 0f64, -0.28f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        -0.51f64, 0f64, -0.21f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        -0.48f64, 0f64, 0.19f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64,
-    ];
+impl RotationalElements for Thalassa {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            299.36f64,
+            0f64,
+            0f64,
+            &[
+                0.7f64, 0f64, -0.28f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            43.45f64,
+            0f64,
+            0f64,
+            &[
+                -0.51f64, 0f64, -0.21f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            102.06f64,
+            1155.7555612f64,
+            0f64,
+            &[
+                -0.48f64, 0f64, 0.19f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Despina;
@@ -2940,26 +4963,43 @@ impl TriAxial for Despina {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Despina {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [299.36f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [43.45f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [306.51f64, 1075.7341562f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Despina {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0.7f64, 0f64, 0f64, -0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        -0.51f64, 0f64, 0f64, -0.07f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        -0.49f64, 0f64, 0f64, 0.06f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64,
-    ];
+impl RotationalElements for Despina {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            299.36f64,
+            0f64,
+            0f64,
+            &[
+                0.7f64, 0f64, 0f64, -0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            43.45f64,
+            0f64,
+            0f64,
+            &[
+                -0.51f64, 0f64, 0f64, -0.07f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            306.51f64,
+            1075.7341562f64,
+            0f64,
+            &[
+                -0.49f64, 0f64, 0f64, 0.06f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Galatea;
@@ -2990,26 +5030,43 @@ impl TriAxial for Galatea {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Galatea {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [299.36f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [43.43f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [258.09f64, 839.6597686f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Galatea {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0.7f64, 0f64, 0f64, 0f64, -0.07f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        -0.51f64, 0f64, 0f64, 0f64, -0.05f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        -0.48f64, 0f64, 0f64, 0f64, 0.05f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64,
-    ];
+impl RotationalElements for Galatea {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            299.36f64,
+            0f64,
+            0f64,
+            &[
+                0.7f64, 0f64, 0f64, 0f64, -0.07f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            43.43f64,
+            0f64,
+            0f64,
+            &[
+                -0.51f64, 0f64, 0f64, 0f64, -0.05f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            258.09f64,
+            839.6597686f64,
+            0f64,
+            &[
+                -0.48f64, 0f64, 0f64, 0f64, 0.05f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Larissa;
@@ -3040,26 +5097,43 @@ impl TriAxial for Larissa {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Larissa {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [299.36f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [43.41f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [179.41f64, 649.053447f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Larissa {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0.7f64, 0f64, 0f64, 0f64, 0f64, -0.27f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        -0.51f64, 0f64, 0f64, 0f64, 0f64, -0.2f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        -0.48f64, 0f64, 0f64, 0f64, 0f64, 0.19f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64,
-    ];
+impl RotationalElements for Larissa {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            299.36f64,
+            0f64,
+            0f64,
+            &[
+                0.7f64, 0f64, 0f64, 0f64, 0f64, -0.27f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            43.41f64,
+            0f64,
+            0f64,
+            &[
+                -0.51f64, 0f64, 0f64, 0f64, 0f64, -0.2f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            179.41f64,
+            649.053447f64,
+            0f64,
+            &[
+                -0.48f64, 0f64, 0f64, 0f64, 0f64, 0.19f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Proteus;
@@ -3090,26 +5164,43 @@ impl TriAxial for Proteus {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Proteus {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [299.27f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [42.91f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [93.38f64, 320.7654228f64, 0f64];
-}
-#[allow(clippy::approx_constant)]
-impl BodyTrigRotationalElements for Proteus {
-    const NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        0.7f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.05f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_DECLINATION_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        -0.51f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64,
-    ];
-    const NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS: &'static [PolynomialCoefficient] = &[
-        -0.48f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-        0f64, 0f64, 0f64,
-    ];
+impl RotationalElements for Proteus {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (
+            299.27f64,
+            0f64,
+            0f64,
+            &[
+                0.7f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.05f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (
+            42.91f64,
+            0f64,
+            0f64,
+            &[
+                -0.51f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (
+            93.38f64,
+            320.7654228f64,
+            0f64,
+            &[
+                -0.48f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                0f64, 0f64, 0f64, 0f64, 0f64,
+            ] as &[f64],
+        )
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Halimede;
@@ -3118,6 +5209,21 @@ impl NaifId for Halimede {
         809i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Halimede {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Psamathe;
 impl NaifId for Psamathe {
@@ -3125,6 +5231,21 @@ impl NaifId for Psamathe {
         810i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Psamathe {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Sao;
 impl NaifId for Sao {
@@ -3132,6 +5253,21 @@ impl NaifId for Sao {
         811i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Sao {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Laomedeia;
 impl NaifId for Laomedeia {
@@ -3139,6 +5275,21 @@ impl NaifId for Laomedeia {
         812i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Laomedeia {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Neso;
 impl NaifId for Neso {
@@ -3146,6 +5297,21 @@ impl NaifId for Neso {
         813i32
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Neso {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Charon;
 impl NaifId for Charon {
@@ -3175,11 +5341,19 @@ impl TriAxial for Charon {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Charon {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [132.993f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [-6.163f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] =
-        [122.695f64, 56.3625225f64, 0f64];
+impl RotationalElements for Charon {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (132.993f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (-6.163f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (122.695f64, 56.3625225f64, 0f64, &[] as &[f64])
+    }
 }
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Nix;
@@ -3193,6 +5367,21 @@ impl PointMass for Nix {
         0.00304817564816976f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Nix {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Hydra;
 impl NaifId for Hydra {
@@ -3205,6 +5394,21 @@ impl PointMass for Hydra {
         0.003211039206155255f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Hydra {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Kerberos;
 impl NaifId for Kerberos {
@@ -3217,6 +5421,21 @@ impl PointMass for Kerberos {
         0.001110040850536676f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Kerberos {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Styx;
 impl NaifId for Styx {
@@ -3229,6 +5448,21 @@ impl PointMass for Styx {
         0f64
     }
 }
+#[allow(clippy::approx_constant)]
+impl RotationalElements for Styx {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (0f64, 0f64, 0f64, &[] as &[f64])
+    }
+}
 #[cfg(test)]
 #[allow(clippy::approx_constant)]
 mod tests {
@@ -3249,51 +5483,55 @@ mod tests {
         assert_eq!(Moon::along_orbit_radius(), 1737.4f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_301() {
-        assert_eq!(
-            [269.9949f64, 0.0031f64, 0f64],
-            Moon::RIGHT_ASCENSION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_declination_coefficients_301() {
-        assert_eq!([66.5392f64, 0.013f64, 0f64], Moon::DECLINATION_COEFFICIENTS)
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_301() {
+    fn test_rotational_elements_nutation_precession_coefficients_301() {
         assert_eq!(
-            [38.3213f64, 13.17635815f64, -0.0000000000014f64],
-            Moon::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Moon::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients301() {
+    fn test_rotational_elements_right_ascension_coefficients_301() {
         assert_eq!(
-            &[
-                -3.8787f64, -0.1204f64, 0.07f64, -0.0172f64, 0f64, 0.0072f64, 0f64, 0f64, 0f64,
-                -0.0052f64, 0f64, 0f64, 0.0043f64
-            ],
-            Moon::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                269.9949f64,
+                0.0031f64,
+                0f64,
+                &[
+                    -3.8787f64, -0.1204f64, 0.07f64, -0.0172f64, 0f64, 0.0072f64, 0f64, 0f64, 0f64,
+                    -0.0052f64, 0f64, 0f64, 0.0043f64
+                ] as &[f64]
+            ),
+            Moon::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients301() {
+    fn test_rotational_elements_declination_coefficients_301() {
         assert_eq!(
-            &[
-                1.5419f64, 0.0239f64, -0.0278f64, 0.0068f64, 0f64, -0.0029f64, 0.0009f64, 0f64,
-                0f64, 0.0008f64, 0f64, 0f64, -0.0009f64
-            ],
-            Moon::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                66.5392f64,
+                0.013f64,
+                0f64,
+                &[
+                    1.5419f64, 0.0239f64, -0.0278f64, 0.0068f64, 0f64, -0.0029f64, 0.0009f64, 0f64,
+                    0f64, 0.0008f64, 0f64, 0f64, -0.0009f64
+                ] as &[f64]
+            ),
+            Moon::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients301() {
+    fn test_rotational_elements_prime_meridian_coefficients_301() {
         assert_eq!(
-            &[
-                3.561f64, 0.1208f64, -0.0642f64, 0.0158f64, 0.0252f64, -0.0066f64, -0.0047f64,
-                -0.0046f64, 0.0028f64, 0.0052f64, 0.004f64, 0.0019f64, -0.0044f64
-            ],
-            Moon::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                38.3213f64,
+                13.17635815f64,
+                -0.0000000000014f64,
+                &[
+                    3.561f64, 0.1208f64, -0.0642f64, 0.0158f64, 0.0252f64, -0.0066f64, -0.0047f64,
+                    -0.0046f64, 0.0028f64, 0.0052f64, 0.004f64, 0.0019f64, -0.0044f64
+                ] as &[f64]
+            ),
+            Moon::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -3312,60 +5550,57 @@ mod tests {
         assert_eq!(Phobos::along_orbit_radius(), 11.4f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_401() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Phobos::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_401() {
         assert_eq!(
-            [317.67071657f64, -0.10844326f64, 0f64],
-            Phobos::RIGHT_ASCENSION_COEFFICIENTS
+            (
+                317.67071657f64,
+                -0.10844326f64,
+                0f64,
+                &[
+                    -1.78428399f64,
+                    0.02212824f64,
+                    -0.01028251f64,
+                    -0.00475595f64
+                ] as &[f64]
+            ),
+            Phobos::right_ascension_coefficients()
         )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_401() {
         assert_eq!(
-            [52.88627266f64, -0.06134706f64, 0f64],
-            Phobos::DECLINATION_COEFFICIENTS
+            (
+                52.88627266f64,
+                -0.06134706f64,
+                0f64,
+                &[-1.07516537f64, 0.00668626f64, -0.0064874f64, 0.00281576f64] as &[f64]
+            ),
+            Phobos::declination_coefficients()
         )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_401() {
         assert_eq!(
-            [
+            (
                 35.1877444f64,
                 1128.84475928f64,
-                0.000000009536137031212154f64
-            ],
-            Phobos::PRIME_MERIDIAN_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients401() {
-        assert_eq!(
-            &[
-                -1.78428399f64,
-                0.02212824f64,
-                -0.01028251f64,
-                -0.00475595f64
-            ],
-            Phobos::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients401() {
-        assert_eq!(
-            &[-1.07516537f64, 0.00668626f64, -0.0064874f64, 0.00281576f64],
-            Phobos::NUT_PREC_DECLINATION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients401() {
-        assert_eq!(
-            &[
-                1.42421769f64,
-                -0.02273783f64,
-                0.00410711f64,
-                0.00631964f64,
-                -1.143f64
-            ],
-            Phobos::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+                0.000000009536137031212154f64,
+                &[
+                    1.42421769f64,
+                    -0.02273783f64,
+                    0.00410711f64,
+                    0.00631964f64,
+                    -1.143f64
+                ] as &[f64]
+            ),
+            Phobos::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -3384,78 +5619,79 @@ mod tests {
         assert_eq!(Deimos::along_orbit_radius(), 6f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_402() {
-        assert_eq!(
-            [316.65705808f64, -0.10518014f64, 0f64],
-            Deimos::RIGHT_ASCENSION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_declination_coefficients_402() {
-        assert_eq!(
-            [53.50992033f64, -0.05979094f64, 0f64],
-            Deimos::DECLINATION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_402() {
+    fn test_rotational_elements_nutation_precession_coefficients_402() {
         assert_eq!(
-            [79.39932954f64, 285.16188899f64, 0f64],
-            Deimos::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Deimos::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients402() {
+    fn test_rotational_elements_right_ascension_coefficients_402() {
         assert_eq!(
-            &[
-                0f64,
-                0f64,
-                0f64,
-                0f64,
+            (
+                316.65705808f64,
+                -0.10518014f64,
                 0f64,
-                3.09217726f64,
-                0.22980637f64,
-                0.06418655f64,
-                0.02533537f64,
-                0.00778695f64
-            ],
-            Deimos::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+                &[
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    3.09217726f64,
+                    0.22980637f64,
+                    0.06418655f64,
+                    0.02533537f64,
+                    0.00778695f64
+                ] as &[f64]
+            ),
+            Deimos::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients402() {
+    fn test_rotational_elements_declination_coefficients_402() {
         assert_eq!(
-            &[
-                0f64,
-                0f64,
+            (
+                53.50992033f64,
+                -0.05979094f64,
                 0f64,
-                0f64,
-                0f64,
-                1.83936004f64,
-                0.1432532f64,
-                0.01911409f64,
-                -0.0148259f64,
-                0.0019243f64
-            ],
-            Deimos::NUT_PREC_DECLINATION_COEFFICIENTS
+                &[
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    1.83936004f64,
+                    0.1432532f64,
+                    0.01911409f64,
+                    -0.0148259f64,
+                    0.0019243f64
+                ] as &[f64]
+            ),
+            Deimos::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients402() {
+    fn test_rotational_elements_prime_meridian_coefficients_402() {
         assert_eq!(
-            &[
+            (
+                79.39932954f64,
+                285.16188899f64,
                 0f64,
-                0f64,
-                0f64,
-                0f64,
-                0f64,
-                -2.73954829f64,
-                -0.39968606f64,
-                -0.06563259f64,
-                -0.0291294f64,
-                0.0169916f64
-            ],
-            Deimos::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+                &[
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    0f64,
+                    -2.73954829f64,
+                    -0.39968606f64,
+                    -0.06563259f64,
+                    -0.0291294f64,
+                    0.0169916f64
+                ] as &[f64]
+            ),
+            Deimos::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -3474,42 +5710,46 @@ mod tests {
         assert_eq!(Io::along_orbit_radius(), 1819.4f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_501() {
-        assert_eq!(
-            [268.05f64, -0.009f64, 0f64],
-            Io::RIGHT_ASCENSION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_declination_coefficients_501() {
-        assert_eq!([64.5f64, 0.003f64, 0f64], Io::DECLINATION_COEFFICIENTS)
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_501() {
+    fn test_rotational_elements_nutation_precession_coefficients_501() {
         assert_eq!(
-            [200.39f64, 203.4889538f64, 0f64],
-            Io::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Io::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients501() {
+    fn test_rotational_elements_right_ascension_coefficients_501() {
         assert_eq!(
-            &[0f64, 0f64, 0.094f64, 0.024f64],
-            Io::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                268.05f64,
+                -0.009f64,
+                0f64,
+                &[0f64, 0f64, 0.094f64, 0.024f64] as &[f64]
+            ),
+            Io::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients501() {
+    fn test_rotational_elements_declination_coefficients_501() {
         assert_eq!(
-            &[0f64, 0f64, 0.04f64, 0.011f64],
-            Io::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                64.5f64,
+                0.003f64,
+                0f64,
+                &[0f64, 0f64, 0.04f64, 0.011f64] as &[f64]
+            ),
+            Io::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients501() {
+    fn test_rotational_elements_prime_meridian_coefficients_501() {
         assert_eq!(
-            &[0f64, 0f64, -0.085f64, -0.022f64],
-            Io::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                200.39f64,
+                203.4889538f64,
+                0f64,
+                &[0f64, 0f64, -0.085f64, -0.022f64] as &[f64]
+            ),
+            Io::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -3528,42 +5768,46 @@ mod tests {
         assert_eq!(Europa::along_orbit_radius(), 1560.3f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_502() {
-        assert_eq!(
-            [268.08f64, -0.009f64, 0f64],
-            Europa::RIGHT_ASCENSION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_declination_coefficients_502() {
-        assert_eq!([64.51f64, 0.003f64, 0f64], Europa::DECLINATION_COEFFICIENTS)
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_502() {
+    fn test_rotational_elements_nutation_precession_coefficients_502() {
         assert_eq!(
-            [36.022f64, 101.3747235f64, 0f64],
-            Europa::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Europa::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients502() {
+    fn test_rotational_elements_right_ascension_coefficients_502() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, 1.086f64, 0.06f64, 0.015f64, 0.009f64],
-            Europa::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                268.08f64,
+                -0.009f64,
+                0f64,
+                &[0f64, 0f64, 0f64, 1.086f64, 0.06f64, 0.015f64, 0.009f64] as &[f64]
+            ),
+            Europa::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients502() {
+    fn test_rotational_elements_declination_coefficients_502() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, 0.468f64, 0.026f64, 0.007f64, 0.002f64],
-            Europa::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                64.51f64,
+                0.003f64,
+                0f64,
+                &[0f64, 0f64, 0f64, 0.468f64, 0.026f64, 0.007f64, 0.002f64] as &[f64]
+            ),
+            Europa::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients502() {
+    fn test_rotational_elements_prime_meridian_coefficients_502() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, -0.98f64, -0.054f64, -0.014f64, -0.008f64],
-            Europa::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                36.022f64,
+                101.3747235f64,
+                0f64,
+                &[0f64, 0f64, 0f64, -0.98f64, -0.054f64, -0.014f64, -0.008f64] as &[f64]
+            ),
+            Europa::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -3582,45 +5826,46 @@ mod tests {
         assert_eq!(Ganymede::along_orbit_radius(), 2631.2f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_503() {
-        assert_eq!(
-            [268.2f64, -0.009f64, 0f64],
-            Ganymede::RIGHT_ASCENSION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_declination_coefficients_503() {
-        assert_eq!(
-            [64.57f64, 0.003f64, 0f64],
-            Ganymede::DECLINATION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_503() {
+    fn test_rotational_elements_nutation_precession_coefficients_503() {
         assert_eq!(
-            [44.064f64, 50.3176081f64, 0f64],
-            Ganymede::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Ganymede::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients503() {
+    fn test_rotational_elements_right_ascension_coefficients_503() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, -0.037f64, 0.431f64, 0.091f64],
-            Ganymede::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                268.2f64,
+                -0.009f64,
+                0f64,
+                &[0f64, 0f64, 0f64, -0.037f64, 0.431f64, 0.091f64] as &[f64]
+            ),
+            Ganymede::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients503() {
+    fn test_rotational_elements_declination_coefficients_503() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, -0.016f64, 0.186f64, 0.039f64],
-            Ganymede::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                64.57f64,
+                0.003f64,
+                0f64,
+                &[0f64, 0f64, 0f64, -0.016f64, 0.186f64, 0.039f64] as &[f64]
+            ),
+            Ganymede::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients503() {
+    fn test_rotational_elements_prime_meridian_coefficients_503() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, 0.033f64, -0.389f64, -0.082f64],
-            Ganymede::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                44.064f64,
+                50.3176081f64,
+                0f64,
+                &[0f64, 0f64, 0f64, 0.033f64, -0.389f64, -0.082f64] as &[f64]
+            ),
+            Ganymede::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -3639,45 +5884,46 @@ mod tests {
         assert_eq!(Callisto::along_orbit_radius(), 2410.3f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_504() {
-        assert_eq!(
-            [268.72f64, -0.009f64, 0f64],
-            Callisto::RIGHT_ASCENSION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_declination_coefficients_504() {
-        assert_eq!(
-            [64.83f64, 0.003f64, 0f64],
-            Callisto::DECLINATION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_504() {
+    fn test_rotational_elements_nutation_precession_coefficients_504() {
         assert_eq!(
-            [259.51f64, 21.5710715f64, 0f64],
-            Callisto::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Callisto::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients504() {
+    fn test_rotational_elements_right_ascension_coefficients_504() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, 0f64, -0.068f64, 0.59f64, 0f64, 0.01f64],
-            Callisto::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                268.72f64,
+                -0.009f64,
+                0f64,
+                &[0f64, 0f64, 0f64, 0f64, -0.068f64, 0.59f64, 0f64, 0.01f64] as &[f64]
+            ),
+            Callisto::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients504() {
+    fn test_rotational_elements_declination_coefficients_504() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, 0f64, -0.029f64, 0.254f64, 0f64, -0.004f64],
-            Callisto::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                64.83f64,
+                0.003f64,
+                0f64,
+                &[0f64, 0f64, 0f64, 0f64, -0.029f64, 0.254f64, 0f64, -0.004f64] as &[f64]
+            ),
+            Callisto::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients504() {
+    fn test_rotational_elements_prime_meridian_coefficients_504() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, 0f64, 0.061f64, -0.533f64, 0f64, -0.009f64],
-            Callisto::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                259.51f64,
+                21.5710715f64,
+                0f64,
+                &[0f64, 0f64, 0f64, 0f64, 0.061f64, -0.533f64, 0f64, -0.009f64] as &[f64]
+            ),
+            Callisto::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -3696,45 +5942,46 @@ mod tests {
         assert_eq!(Amalthea::along_orbit_radius(), 73f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_505() {
-        assert_eq!(
-            [268.05f64, -0.009f64, 0f64],
-            Amalthea::RIGHT_ASCENSION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_declination_coefficients_505() {
-        assert_eq!(
-            [64.49f64, 0.003f64, 0f64],
-            Amalthea::DECLINATION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_505() {
+    fn test_rotational_elements_nutation_precession_coefficients_505() {
         assert_eq!(
-            [231.67f64, 722.631456f64, 0f64],
-            Amalthea::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Amalthea::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients505() {
+    fn test_rotational_elements_right_ascension_coefficients_505() {
         assert_eq!(
-            &[-0.84f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.01f64, 0f64],
-            Amalthea::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                268.05f64,
+                -0.009f64,
+                0f64,
+                &[-0.84f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.01f64, 0f64] as &[f64]
+            ),
+            Amalthea::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients505() {
+    fn test_rotational_elements_declination_coefficients_505() {
         assert_eq!(
-            &[-0.36f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64],
-            Amalthea::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                64.49f64,
+                0.003f64,
+                0f64,
+                &[-0.36f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64]
+            ),
+            Amalthea::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients505() {
+    fn test_rotational_elements_prime_meridian_coefficients_505() {
         assert_eq!(
-            &[0.76f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.01f64, 0f64],
-            Amalthea::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                231.67f64,
+                722.631456f64,
+                0f64,
+                &[0.76f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.01f64, 0f64] as &[f64]
+            ),
+            Amalthea::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -3753,6 +6000,34 @@ mod tests {
         assert_eq!(Himalia::along_orbit_radius(), 85f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_506() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Himalia::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_506() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Himalia::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_506() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Himalia::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_506() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Himalia::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_507() {
         assert_eq!(Elara::id(), 507i32)
     }
@@ -3764,6 +6039,34 @@ mod tests {
         assert_eq!(Elara::along_orbit_radius(), 40f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_507() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Elara::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_507() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Elara::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_507() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Elara::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_507() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Elara::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_508() {
         assert_eq!(Pasiphae::id(), 508i32)
     }
@@ -3775,6 +6078,34 @@ mod tests {
         assert_eq!(Pasiphae::along_orbit_radius(), 18f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_508() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Pasiphae::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_508() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Pasiphae::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_508() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Pasiphae::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_508() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Pasiphae::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_509() {
         assert_eq!(Sinope::id(), 509i32)
     }
@@ -3786,6 +6117,34 @@ mod tests {
         assert_eq!(Sinope::along_orbit_radius(), 14f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_509() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Sinope::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_509() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Sinope::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_509() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Sinope::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_509() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Sinope::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_510() {
         assert_eq!(Lysithea::id(), 510i32)
     }
@@ -3797,6 +6156,34 @@ mod tests {
         assert_eq!(Lysithea::along_orbit_radius(), 12f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_510() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Lysithea::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_510() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Lysithea::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_510() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Lysithea::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_510() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Lysithea::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_511() {
         assert_eq!(Carme::id(), 511i32)
     }
@@ -3808,6 +6195,34 @@ mod tests {
         assert_eq!(Carme::along_orbit_radius(), 15f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_511() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Carme::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_511() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Carme::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_511() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Carme::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_511() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Carme::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_512() {
         assert_eq!(Ananke::id(), 512i32)
     }
@@ -3819,6 +6234,34 @@ mod tests {
         assert_eq!(Ananke::along_orbit_radius(), 10f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_512() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Ananke::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_512() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Ananke::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_512() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Ananke::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_512() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Ananke::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_513() {
         assert_eq!(Leda::id(), 513i32)
     }
@@ -3830,6 +6273,34 @@ mod tests {
         assert_eq!(Leda::along_orbit_radius(), 5f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_513() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Leda::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_513() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Leda::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_513() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Leda::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_513() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Leda::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_514() {
         assert_eq!(Thebe::id(), 514i32)
     }
@@ -3845,42 +6316,46 @@ mod tests {
         assert_eq!(Thebe::along_orbit_radius(), 49f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_514() {
-        assert_eq!(
-            [268.05f64, -0.009f64, 0f64],
-            Thebe::RIGHT_ASCENSION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_declination_coefficients_514() {
-        assert_eq!([64.49f64, 0.003f64, 0f64], Thebe::DECLINATION_COEFFICIENTS)
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_514() {
+    fn test_rotational_elements_nutation_precession_coefficients_514() {
         assert_eq!(
-            [8.56f64, 533.70041f64, 0f64],
-            Thebe::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Thebe::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients514() {
+    fn test_rotational_elements_right_ascension_coefficients_514() {
         assert_eq!(
-            &[0f64, -2.11f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.04f64],
-            Thebe::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                268.05f64,
+                -0.009f64,
+                0f64,
+                &[0f64, -2.11f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.04f64] as &[f64]
+            ),
+            Thebe::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients514() {
+    fn test_rotational_elements_declination_coefficients_514() {
         assert_eq!(
-            &[0f64, -0.91f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.01f64],
-            Thebe::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                64.49f64,
+                0.003f64,
+                0f64,
+                &[0f64, -0.91f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.01f64] as &[f64]
+            ),
+            Thebe::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients514() {
+    fn test_rotational_elements_prime_meridian_coefficients_514() {
         assert_eq!(
-            &[0f64, 1.91f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.04f64],
-            Thebe::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                8.56f64,
+                533.70041f64,
+                0f64,
+                &[0f64, 1.91f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.04f64] as &[f64]
+            ),
+            Thebe::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -3899,24 +6374,31 @@ mod tests {
         assert_eq!(Adrastea::along_orbit_radius(), 8f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_515() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Adrastea::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_515() {
         assert_eq!(
-            [268.05f64, -0.009f64, 0f64],
-            Adrastea::RIGHT_ASCENSION_COEFFICIENTS
+            (268.05f64, -0.009f64, 0f64, &[] as &[f64]),
+            Adrastea::right_ascension_coefficients()
         )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_515() {
         assert_eq!(
-            [64.49f64, 0.003f64, 0f64],
-            Adrastea::DECLINATION_COEFFICIENTS
+            (64.49f64, 0.003f64, 0f64, &[] as &[f64]),
+            Adrastea::declination_coefficients()
         )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_515() {
         assert_eq!(
-            [33.29f64, 1206.9986602f64, 0f64],
-            Adrastea::PRIME_MERIDIAN_COEFFICIENTS
+            (33.29f64, 1206.9986602f64, 0f64, &[] as &[f64]),
+            Adrastea::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -3935,21 +6417,31 @@ mod tests {
         assert_eq!(Metis::along_orbit_radius(), 20f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_516() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Metis::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_516() {
         assert_eq!(
-            [268.05f64, -0.009f64, 0f64],
-            Metis::RIGHT_ASCENSION_COEFFICIENTS
+            (268.05f64, -0.009f64, 0f64, &[] as &[f64]),
+            Metis::right_ascension_coefficients()
         )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_516() {
-        assert_eq!([64.49f64, 0.003f64, 0f64], Metis::DECLINATION_COEFFICIENTS)
+        assert_eq!(
+            (64.49f64, 0.003f64, 0f64, &[] as &[f64]),
+            Metis::declination_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_516() {
         assert_eq!(
-            [346.09f64, 1221.2547301f64, 0f64],
-            Metis::PRIME_MERIDIAN_COEFFICIENTS
+            (346.09f64, 1221.2547301f64, 0f64, &[] as &[f64]),
+            Metis::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -3957,1977 +6449,4482 @@ mod tests {
         assert_eq!(Callirrhoe::id(), 517i32)
     }
     #[test]
-    fn test_naif_id_518() {
-        assert_eq!(Themisto::id(), 518i32)
+    fn test_rotational_elements_nutation_precession_coefficients_517() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Callirrhoe::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_519() {
-        assert_eq!(Magaclite::id(), 519i32)
+    fn test_rotational_elements_right_ascension_coefficients_517() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Callirrhoe::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_520() {
-        assert_eq!(Taygete::id(), 520i32)
+    fn test_rotational_elements_declination_coefficients_517() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Callirrhoe::declination_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_521() {
-        assert_eq!(Chaldene::id(), 521i32)
+    fn test_rotational_elements_prime_meridian_coefficients_517() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Callirrhoe::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_522() {
-        assert_eq!(Harpalyke::id(), 522i32)
+    fn test_naif_id_518() {
+        assert_eq!(Themisto::id(), 518i32)
     }
     #[test]
-    fn test_naif_id_523() {
-        assert_eq!(Kalyke::id(), 523i32)
-    }
-    #[test]
-    fn test_naif_id_524() {
-        assert_eq!(Iocaste::id(), 524i32)
-    }
-    #[test]
-    fn test_naif_id_525() {
-        assert_eq!(Erinome::id(), 525i32)
+    fn test_rotational_elements_nutation_precession_coefficients_518() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Themisto::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_526() {
-        assert_eq!(Isonoe::id(), 526i32)
+    fn test_rotational_elements_right_ascension_coefficients_518() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Themisto::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_527() {
-        assert_eq!(Praxidike::id(), 527i32)
+    fn test_rotational_elements_declination_coefficients_518() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Themisto::declination_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_528() {
-        assert_eq!(Autonoe::id(), 528i32)
+    fn test_rotational_elements_prime_meridian_coefficients_518() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Themisto::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_529() {
-        assert_eq!(Thyone::id(), 529i32)
+    fn test_naif_id_519() {
+        assert_eq!(Magaclite::id(), 519i32)
     }
     #[test]
-    fn test_naif_id_530() {
-        assert_eq!(Hermippe::id(), 530i32)
+    fn test_rotational_elements_nutation_precession_coefficients_519() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Magaclite::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_531() {
-        assert_eq!(Aitne::id(), 531i32)
+    fn test_rotational_elements_right_ascension_coefficients_519() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Magaclite::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_532() {
-        assert_eq!(Eurydome::id(), 532i32)
+    fn test_rotational_elements_declination_coefficients_519() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Magaclite::declination_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_533() {
-        assert_eq!(Euanthe::id(), 533i32)
+    fn test_rotational_elements_prime_meridian_coefficients_519() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Magaclite::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_534() {
-        assert_eq!(Euporie::id(), 534i32)
+    fn test_naif_id_520() {
+        assert_eq!(Taygete::id(), 520i32)
     }
     #[test]
-    fn test_naif_id_535() {
-        assert_eq!(Orthosie::id(), 535i32)
+    fn test_rotational_elements_nutation_precession_coefficients_520() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Taygete::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_536() {
-        assert_eq!(Sponde::id(), 536i32)
+    fn test_rotational_elements_right_ascension_coefficients_520() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Taygete::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_537() {
-        assert_eq!(Kale::id(), 537i32)
+    fn test_rotational_elements_declination_coefficients_520() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Taygete::declination_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_538() {
-        assert_eq!(Pasithee::id(), 538i32)
+    fn test_rotational_elements_prime_meridian_coefficients_520() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Taygete::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_539() {
-        assert_eq!(Hegemone::id(), 539i32)
+    fn test_naif_id_521() {
+        assert_eq!(Chaldene::id(), 521i32)
     }
     #[test]
-    fn test_naif_id_540() {
-        assert_eq!(Mneme::id(), 540i32)
+    fn test_rotational_elements_nutation_precession_coefficients_521() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Chaldene::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_541() {
-        assert_eq!(Aoede::id(), 541i32)
+    fn test_rotational_elements_right_ascension_coefficients_521() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Chaldene::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_542() {
-        assert_eq!(Thelxinoe::id(), 542i32)
+    fn test_rotational_elements_declination_coefficients_521() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Chaldene::declination_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_543() {
-        assert_eq!(Arche::id(), 543i32)
+    fn test_rotational_elements_prime_meridian_coefficients_521() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Chaldene::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_544() {
-        assert_eq!(Kallichore::id(), 544i32)
+    fn test_naif_id_522() {
+        assert_eq!(Harpalyke::id(), 522i32)
     }
     #[test]
-    fn test_naif_id_545() {
-        assert_eq!(Helike::id(), 545i32)
+    fn test_rotational_elements_nutation_precession_coefficients_522() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Harpalyke::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_546() {
-        assert_eq!(Carpo::id(), 546i32)
+    fn test_rotational_elements_right_ascension_coefficients_522() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Harpalyke::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_547() {
-        assert_eq!(Eukelade::id(), 547i32)
+    fn test_rotational_elements_declination_coefficients_522() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Harpalyke::declination_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_548() {
-        assert_eq!(Cyllene::id(), 548i32)
+    fn test_rotational_elements_prime_meridian_coefficients_522() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Harpalyke::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_549() {
-        assert_eq!(Kore::id(), 549i32)
+    fn test_naif_id_523() {
+        assert_eq!(Kalyke::id(), 523i32)
     }
     #[test]
-    fn test_naif_id_550() {
-        assert_eq!(Herse::id(), 550i32)
+    fn test_rotational_elements_nutation_precession_coefficients_523() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Kalyke::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_553() {
-        assert_eq!(Dia::id(), 553i32)
+    fn test_rotational_elements_right_ascension_coefficients_523() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kalyke::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_601() {
-        assert_eq!(Mimas::id(), 601i32)
+    fn test_rotational_elements_declination_coefficients_523() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kalyke::declination_coefficients()
+        )
     }
     #[test]
-    fn test_point_mass_601() {
-        assert_eq!(Mimas::gravitational_parameter(), 2.503488768152587f64);
+    fn test_rotational_elements_prime_meridian_coefficients_523() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kalyke::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_tri_axial_601() {
-        assert_eq!(Mimas::polar_radius(), 190.6f64);
-        assert_eq!(Mimas::mean_radius(), 198.36666666666667f64);
-        assert_eq!(Mimas::subplanetary_radius(), 207.8f64);
-        assert_eq!(Mimas::along_orbit_radius(), 196.7f64);
+    fn test_naif_id_524() {
+        assert_eq!(Iocaste::id(), 524i32)
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_601() {
+    fn test_rotational_elements_nutation_precession_coefficients_524() {
         assert_eq!(
-            [40.66f64, -0.036f64, 0f64],
-            Mimas::RIGHT_ASCENSION_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Iocaste::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_601() {
-        assert_eq!([83.52f64, -0.004f64, 0f64], Mimas::DECLINATION_COEFFICIENTS)
+    fn test_rotational_elements_right_ascension_coefficients_524() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Iocaste::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_601() {
+    fn test_rotational_elements_declination_coefficients_524() {
         assert_eq!(
-            [333.46f64, 381.994555f64, 0f64],
-            Mimas::PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Iocaste::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients601() {
+    fn test_rotational_elements_prime_meridian_coefficients_524() {
         assert_eq!(
-            &[0f64, 0f64, 13.56f64, 0f64, 0f64, 0f64, 0f64, 0f64],
-            Mimas::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Iocaste::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients601() {
+    fn test_naif_id_525() {
+        assert_eq!(Erinome::id(), 525i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_525() {
         assert_eq!(
-            &[0f64, 0f64, -1.53f64, 0f64, 0f64, 0f64, 0f64, 0f64],
-            Mimas::NUT_PREC_DECLINATION_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Erinome::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients601() {
+    fn test_rotational_elements_right_ascension_coefficients_525() {
         assert_eq!(
-            &[0f64, 0f64, -13.48f64, 0f64, -44.85f64, 0f64, 0f64, 0f64],
-            Mimas::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Erinome::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_602() {
-        assert_eq!(Enceladus::id(), 602i32)
+    fn test_rotational_elements_declination_coefficients_525() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Erinome::declination_coefficients()
+        )
     }
     #[test]
-    fn test_point_mass_602() {
-        assert_eq!(Enceladus::gravitational_parameter(), 7.210366688598896f64);
+    fn test_rotational_elements_prime_meridian_coefficients_525() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Erinome::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_tri_axial_602() {
-        assert_eq!(Enceladus::polar_radius(), 248.3f64);
-        assert_eq!(Enceladus::mean_radius(), 252.1f64);
-        assert_eq!(Enceladus::subplanetary_radius(), 256.6f64);
-        assert_eq!(Enceladus::along_orbit_radius(), 251.4f64);
+    fn test_naif_id_526() {
+        assert_eq!(Isonoe::id(), 526i32)
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_602() {
+    fn test_rotational_elements_nutation_precession_coefficients_526() {
         assert_eq!(
-            [40.66f64, -0.036f64, 0f64],
-            Enceladus::RIGHT_ASCENSION_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Isonoe::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_602() {
+    fn test_rotational_elements_right_ascension_coefficients_526() {
         assert_eq!(
-            [83.52f64, -0.004f64, 0f64],
-            Enceladus::DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Isonoe::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_602() {
+    fn test_rotational_elements_declination_coefficients_526() {
         assert_eq!(
-            [6.32f64, 262.7318996f64, 0f64],
-            Enceladus::PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Isonoe::declination_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_603() {
-        assert_eq!(Tethys::id(), 603i32)
+    fn test_rotational_elements_prime_meridian_coefficients_526() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Isonoe::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_point_mass_603() {
-        assert_eq!(Tethys::gravitational_parameter(), 41.21352885489587f64);
+    fn test_naif_id_527() {
+        assert_eq!(Praxidike::id(), 527i32)
     }
     #[test]
-    fn test_tri_axial_603() {
-        assert_eq!(Tethys::polar_radius(), 526.3f64);
-        assert_eq!(Tethys::mean_radius(), 530.9999999999999f64);
-        assert_eq!(Tethys::subplanetary_radius(), 538.4f64);
-        assert_eq!(Tethys::along_orbit_radius(), 528.3f64);
+    fn test_rotational_elements_nutation_precession_coefficients_527() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Praxidike::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_603() {
+    fn test_rotational_elements_right_ascension_coefficients_527() {
         assert_eq!(
-            [40.66f64, -0.036f64, 0f64],
-            Tethys::RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Praxidike::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_603() {
+    fn test_rotational_elements_declination_coefficients_527() {
         assert_eq!(
-            [83.52f64, -0.004f64, 0f64],
-            Tethys::DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Praxidike::declination_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_603() {
+    fn test_rotational_elements_prime_meridian_coefficients_527() {
         assert_eq!(
-            [8.95f64, 190.6979085f64, 0f64],
-            Tethys::PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Praxidike::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients603() {
+    fn test_naif_id_528() {
+        assert_eq!(Autonoe::id(), 528i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_528() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, 9.66f64, 0f64, 0f64, 0f64, 0f64],
-            Tethys::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Autonoe::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients603() {
+    fn test_rotational_elements_right_ascension_coefficients_528() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, -1.09f64, 0f64, 0f64, 0f64, 0f64],
-            Tethys::NUT_PREC_DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Autonoe::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients603() {
+    fn test_rotational_elements_declination_coefficients_528() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, -9.6f64, 2.23f64, 0f64, 0f64, 0f64],
-            Tethys::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Autonoe::declination_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_604() {
-        assert_eq!(Dione::id(), 604i32)
+    fn test_rotational_elements_prime_meridian_coefficients_528() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Autonoe::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_point_mass_604() {
-        assert_eq!(Dione::gravitational_parameter(), 73.11607172482067f64);
+    fn test_naif_id_529() {
+        assert_eq!(Thyone::id(), 529i32)
     }
     #[test]
-    fn test_tri_axial_604() {
-        assert_eq!(Dione::polar_radius(), 559.6f64);
-        assert_eq!(Dione::mean_radius(), 561.4333333333333f64);
-        assert_eq!(Dione::subplanetary_radius(), 563.4f64);
-        assert_eq!(Dione::along_orbit_radius(), 561.3f64);
+    fn test_rotational_elements_nutation_precession_coefficients_529() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Thyone::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_604() {
+    fn test_rotational_elements_right_ascension_coefficients_529() {
         assert_eq!(
-            [40.66f64, -0.036f64, 0f64],
-            Dione::RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Thyone::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_604() {
-        assert_eq!([83.52f64, -0.004f64, 0f64], Dione::DECLINATION_COEFFICIENTS)
+    fn test_rotational_elements_declination_coefficients_529() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Thyone::declination_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_604() {
+    fn test_rotational_elements_prime_meridian_coefficients_529() {
         assert_eq!(
-            [357.6f64, 131.5349316f64, 0f64],
-            Dione::PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Thyone::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_605() {
-        assert_eq!(Rhea::id(), 605i32)
+    fn test_naif_id_530() {
+        assert_eq!(Hermippe::id(), 530i32)
     }
     #[test]
-    fn test_point_mass_605() {
-        assert_eq!(Rhea::gravitational_parameter(), 153.9417519146563f64);
+    fn test_rotational_elements_nutation_precession_coefficients_530() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Hermippe::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_tri_axial_605() {
-        assert_eq!(Rhea::polar_radius(), 762.4f64);
-        assert_eq!(Rhea::mean_radius(), 763.5f64);
-        assert_eq!(Rhea::subplanetary_radius(), 765f64);
-        assert_eq!(Rhea::along_orbit_radius(), 763.1f64);
+    fn test_rotational_elements_right_ascension_coefficients_530() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Hermippe::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_605() {
+    fn test_rotational_elements_declination_coefficients_530() {
         assert_eq!(
-            [40.38f64, -0.036f64, 0f64],
-            Rhea::RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Hermippe::declination_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_605() {
-        assert_eq!([83.55f64, -0.004f64, 0f64], Rhea::DECLINATION_COEFFICIENTS)
+    fn test_rotational_elements_prime_meridian_coefficients_530() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Hermippe::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_605() {
+    fn test_naif_id_531() {
+        assert_eq!(Aitne::id(), 531i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_531() {
         assert_eq!(
-            [235.16f64, 79.6900478f64, 0f64],
-            Rhea::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Aitne::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients605() {
+    fn test_rotational_elements_right_ascension_coefficients_531() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, 0f64, 0f64, 3.1f64, 0f64, 0f64],
-            Rhea::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Aitne::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients605() {
+    fn test_rotational_elements_declination_coefficients_531() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, 0f64, 0f64, -0.35f64, 0f64, 0f64],
-            Rhea::NUT_PREC_DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Aitne::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients605() {
+    fn test_rotational_elements_prime_meridian_coefficients_531() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, 0f64, 0f64, -3.08f64, 0f64, 0f64],
-            Rhea::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Aitne::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_606() {
-        assert_eq!(Titan::id(), 606i32)
+    fn test_naif_id_532() {
+        assert_eq!(Eurydome::id(), 532i32)
     }
     #[test]
-    fn test_point_mass_606() {
-        assert_eq!(Titan::gravitational_parameter(), 8978.137095521046f64);
+    fn test_rotational_elements_nutation_precession_coefficients_532() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Eurydome::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_tri_axial_606() {
-        assert_eq!(Titan::polar_radius(), 2574.47f64);
-        assert_eq!(Titan::mean_radius(), 2574.7999999999997f64);
-        assert_eq!(Titan::subplanetary_radius(), 2575.15f64);
-        assert_eq!(Titan::along_orbit_radius(), 2574.78f64);
+    fn test_rotational_elements_right_ascension_coefficients_532() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Eurydome::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_606() {
+    fn test_rotational_elements_declination_coefficients_532() {
         assert_eq!(
-            [39.4827f64, 0f64, 0f64],
-            Titan::RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Eurydome::declination_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_606() {
-        assert_eq!([83.4279f64, 0f64, 0f64], Titan::DECLINATION_COEFFICIENTS)
+    fn test_rotational_elements_prime_meridian_coefficients_532() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Eurydome::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_606() {
+    fn test_naif_id_533() {
+        assert_eq!(Euanthe::id(), 533i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_533() {
         assert_eq!(
-            [186.5855f64, 22.5769768f64, 0f64],
-            Titan::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Euanthe::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients606() {
+    fn test_rotational_elements_right_ascension_coefficients_533() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64],
-            Titan::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Euanthe::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients606() {
+    fn test_rotational_elements_declination_coefficients_533() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64],
-            Titan::NUT_PREC_DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Euanthe::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients606() {
+    fn test_rotational_elements_prime_meridian_coefficients_533() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64],
-            Titan::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Euanthe::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_607() {
-        assert_eq!(Hyperion::id(), 607i32)
+    fn test_naif_id_534() {
+        assert_eq!(Euporie::id(), 534i32)
     }
     #[test]
-    fn test_point_mass_607() {
-        assert_eq!(Hyperion::gravitational_parameter(), 0.3704913747932265f64);
+    fn test_rotational_elements_nutation_precession_coefficients_534() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Euporie::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_tri_axial_607() {
-        assert_eq!(Hyperion::polar_radius(), 102.7f64);
-        assert_eq!(Hyperion::mean_radius(), 138.6f64);
-        assert_eq!(Hyperion::subplanetary_radius(), 180.1f64);
-        assert_eq!(Hyperion::along_orbit_radius(), 133f64);
+    fn test_rotational_elements_right_ascension_coefficients_534() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Euporie::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_608() {
-        assert_eq!(Iapetus::id(), 608i32)
+    fn test_rotational_elements_declination_coefficients_534() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Euporie::declination_coefficients()
+        )
     }
     #[test]
-    fn test_point_mass_608() {
-        assert_eq!(Iapetus::gravitational_parameter(), 120.5151060137642f64);
+    fn test_rotational_elements_prime_meridian_coefficients_534() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Euporie::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_tri_axial_608() {
-        assert_eq!(Iapetus::polar_radius(), 712.1f64);
-        assert_eq!(Iapetus::mean_radius(), 734.5f64);
-        assert_eq!(Iapetus::subplanetary_radius(), 745.7f64);
-        assert_eq!(Iapetus::along_orbit_radius(), 745.7f64);
+    fn test_naif_id_535() {
+        assert_eq!(Orthosie::id(), 535i32)
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_608() {
+    fn test_rotational_elements_nutation_precession_coefficients_535() {
         assert_eq!(
-            [318.16f64, -3.949f64, 0f64],
-            Iapetus::RIGHT_ASCENSION_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Orthosie::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_608() {
+    fn test_rotational_elements_right_ascension_coefficients_535() {
         assert_eq!(
-            [75.03f64, -1.143f64, 0f64],
-            Iapetus::DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Orthosie::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_608() {
+    fn test_rotational_elements_declination_coefficients_535() {
         assert_eq!(
-            [355.2f64, 4.5379572f64, 0f64],
-            Iapetus::PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Orthosie::declination_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_609() {
-        assert_eq!(Phoebe::id(), 609i32)
+    fn test_rotational_elements_prime_meridian_coefficients_535() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Orthosie::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_point_mass_609() {
-        assert_eq!(Phoebe::gravitational_parameter(), 0.5547860052791678f64);
+    fn test_naif_id_536() {
+        assert_eq!(Sponde::id(), 536i32)
     }
     #[test]
-    fn test_tri_axial_609() {
-        assert_eq!(Phoebe::polar_radius(), 101.8f64);
-        assert_eq!(Phoebe::mean_radius(), 106.56666666666666f64);
-        assert_eq!(Phoebe::subplanetary_radius(), 109.4f64);
-        assert_eq!(Phoebe::along_orbit_radius(), 108.5f64);
+    fn test_rotational_elements_nutation_precession_coefficients_536() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Sponde::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_609() {
-        assert_eq!([356.9f64, 0f64, 0f64], Phoebe::RIGHT_ASCENSION_COEFFICIENTS)
+    fn test_rotational_elements_right_ascension_coefficients_536() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Sponde::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_609() {
-        assert_eq!([77.8f64, 0f64, 0f64], Phoebe::DECLINATION_COEFFICIENTS)
+    fn test_rotational_elements_declination_coefficients_536() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Sponde::declination_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_609() {
+    fn test_rotational_elements_prime_meridian_coefficients_536() {
         assert_eq!(
-            [178.58f64, 931.639f64, 0f64],
-            Phoebe::PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Sponde::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_610() {
-        assert_eq!(Janus::id(), 610i32)
+    fn test_naif_id_537() {
+        assert_eq!(Kale::id(), 537i32)
     }
     #[test]
-    fn test_point_mass_610() {
-        assert_eq!(Janus::gravitational_parameter(), 0.1265765099012197f64);
+    fn test_rotational_elements_nutation_precession_coefficients_537() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Kale::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_tri_axial_610() {
-        assert_eq!(Janus::polar_radius(), 76.3f64);
-        assert_eq!(Janus::mean_radius(), 90.33333333333333f64);
-        assert_eq!(Janus::subplanetary_radius(), 101.7f64);
-        assert_eq!(Janus::along_orbit_radius(), 93f64);
+    fn test_rotational_elements_right_ascension_coefficients_537() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kale::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_610() {
+    fn test_rotational_elements_declination_coefficients_537() {
         assert_eq!(
-            [40.58f64, -0.036f64, 0f64],
-            Janus::RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kale::declination_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_610() {
-        assert_eq!([83.52f64, -0.004f64, 0f64], Janus::DECLINATION_COEFFICIENTS)
+    fn test_rotational_elements_prime_meridian_coefficients_537() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kale::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_610() {
+    fn test_naif_id_538() {
+        assert_eq!(Pasithee::id(), 538i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_538() {
         assert_eq!(
-            [58.83f64, 518.2359876f64, 0f64],
-            Janus::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Pasithee::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients610() {
+    fn test_rotational_elements_right_ascension_coefficients_538() {
         assert_eq!(
-            &[0f64, -1.623f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.023f64],
-            Janus::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Pasithee::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients610() {
+    fn test_rotational_elements_declination_coefficients_538() {
         assert_eq!(
-            &[0f64, -0.183f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.001f64],
-            Janus::NUT_PREC_DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Pasithee::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients610() {
+    fn test_rotational_elements_prime_meridian_coefficients_538() {
         assert_eq!(
-            &[0f64, 1.613f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.023f64],
-            Janus::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Pasithee::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_611() {
-        assert_eq!(Epimetheus::id(), 611i32)
+    fn test_naif_id_539() {
+        assert_eq!(Hegemone::id(), 539i32)
     }
     #[test]
-    fn test_point_mass_611() {
+    fn test_rotational_elements_nutation_precession_coefficients_539() {
         assert_eq!(
-            Epimetheus::gravitational_parameter(),
-            0.03512333288208074f64
-        );
-    }
-    #[test]
-    fn test_tri_axial_611() {
-        assert_eq!(Epimetheus::polar_radius(), 53f64);
-        assert_eq!(Epimetheus::mean_radius(), 58.4f64);
-        assert_eq!(Epimetheus::subplanetary_radius(), 64.9f64);
-        assert_eq!(Epimetheus::along_orbit_radius(), 57.3f64);
+            (&[] as &[f64], &[] as &[f64]),
+            Hegemone::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_611() {
+    fn test_rotational_elements_right_ascension_coefficients_539() {
         assert_eq!(
-            [40.58f64, -0.036f64, 0f64],
-            Epimetheus::RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Hegemone::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_611() {
+    fn test_rotational_elements_declination_coefficients_539() {
         assert_eq!(
-            [83.52f64, -0.004f64, 0f64],
-            Epimetheus::DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Hegemone::declination_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_611() {
+    fn test_rotational_elements_prime_meridian_coefficients_539() {
         assert_eq!(
-            [293.87f64, 518.4907239f64, 0f64],
-            Epimetheus::PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Hegemone::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients611() {
+    fn test_naif_id_540() {
+        assert_eq!(Mneme::id(), 540i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_540() {
         assert_eq!(
-            &[-3.153f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.086f64, 0f64],
-            Epimetheus::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Mneme::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients611() {
+    fn test_rotational_elements_right_ascension_coefficients_540() {
         assert_eq!(
-            &[-0.356f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.005f64, 0f64],
-            Epimetheus::NUT_PREC_DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Mneme::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients611() {
+    fn test_rotational_elements_declination_coefficients_540() {
         assert_eq!(
-            &[3.133f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.086f64, 0f64],
-            Epimetheus::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Mneme::declination_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_612() {
-        assert_eq!(Helene::id(), 612i32)
+    fn test_rotational_elements_prime_meridian_coefficients_540() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Mneme::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_point_mass_612() {
-        assert_eq!(Helene::gravitational_parameter(), 0.0004757419551776972f64);
+    fn test_naif_id_541() {
+        assert_eq!(Aoede::id(), 541i32)
     }
     #[test]
-    fn test_tri_axial_612() {
-        assert_eq!(Helene::polar_radius(), 13.3f64);
-        assert_eq!(Helene::mean_radius(), 18.46666666666667f64);
-        assert_eq!(Helene::subplanetary_radius(), 22.5f64);
-        assert_eq!(Helene::along_orbit_radius(), 19.6f64);
+    fn test_rotational_elements_nutation_precession_coefficients_541() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Aoede::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_612() {
+    fn test_rotational_elements_right_ascension_coefficients_541() {
         assert_eq!(
-            [40.85f64, -0.036f64, 0f64],
-            Helene::RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Aoede::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_612() {
+    fn test_rotational_elements_declination_coefficients_541() {
         assert_eq!(
-            [83.34f64, -0.004f64, 0f64],
-            Helene::DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Aoede::declination_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_612() {
+    fn test_rotational_elements_prime_meridian_coefficients_541() {
         assert_eq!(
-            [245.12f64, 131.6174056f64, 0f64],
-            Helene::PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Aoede::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_613() {
-        assert_eq!(Telesto::id(), 613i32)
+    fn test_naif_id_542() {
+        assert_eq!(Thelxinoe::id(), 542i32)
     }
     #[test]
-    fn test_tri_axial_613() {
-        assert_eq!(Telesto::polar_radius(), 9.8f64);
-        assert_eq!(Telesto::mean_radius(), 12.633333333333335f64);
-        assert_eq!(Telesto::subplanetary_radius(), 16.3f64);
-        assert_eq!(Telesto::along_orbit_radius(), 11.8f64);
+    fn test_rotational_elements_nutation_precession_coefficients_542() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Thelxinoe::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_613() {
+    fn test_rotational_elements_right_ascension_coefficients_542() {
         assert_eq!(
-            [50.51f64, -0.036f64, 0f64],
-            Telesto::RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Thelxinoe::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_613() {
+    fn test_rotational_elements_declination_coefficients_542() {
         assert_eq!(
-            [84.06f64, -0.004f64, 0f64],
-            Telesto::DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Thelxinoe::declination_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_613() {
+    fn test_rotational_elements_prime_meridian_coefficients_542() {
         assert_eq!(
-            [56.88f64, 190.6979332f64, 0f64],
-            Telesto::PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Thelxinoe::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_614() {
-        assert_eq!(Calypso::id(), 614i32)
+    fn test_naif_id_543() {
+        assert_eq!(Arche::id(), 543i32)
     }
     #[test]
-    fn test_tri_axial_614() {
-        assert_eq!(Calypso::polar_radius(), 6.3f64);
-        assert_eq!(Calypso::mean_radius(), 10.3f64);
-        assert_eq!(Calypso::subplanetary_radius(), 15.3f64);
-        assert_eq!(Calypso::along_orbit_radius(), 9.3f64);
+    fn test_rotational_elements_nutation_precession_coefficients_543() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Arche::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_614() {
+    fn test_rotational_elements_right_ascension_coefficients_543() {
         assert_eq!(
-            [36.41f64, -0.036f64, 0f64],
-            Calypso::RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Arche::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_614() {
+    fn test_rotational_elements_declination_coefficients_543() {
         assert_eq!(
-            [85.04f64, -0.004f64, 0f64],
-            Calypso::DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Arche::declination_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_614() {
+    fn test_rotational_elements_prime_meridian_coefficients_543() {
         assert_eq!(
-            [153.51f64, 190.6742373f64, 0f64],
-            Calypso::PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Arche::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_615() {
-        assert_eq!(Atlas::id(), 615i32)
+    fn test_naif_id_544() {
+        assert_eq!(Kallichore::id(), 544i32)
     }
     #[test]
-    fn test_point_mass_615() {
-        assert_eq!(Atlas::gravitational_parameter(), 0.0003718871247516475f64);
+    fn test_rotational_elements_nutation_precession_coefficients_544() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Kallichore::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_tri_axial_615() {
-        assert_eq!(Atlas::polar_radius(), 9.4f64);
-        assert_eq!(Atlas::mean_radius(), 15.899999999999999f64);
-        assert_eq!(Atlas::subplanetary_radius(), 20.5f64);
-        assert_eq!(Atlas::along_orbit_radius(), 17.8f64);
+    fn test_rotational_elements_right_ascension_coefficients_544() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kallichore::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_615() {
+    fn test_rotational_elements_declination_coefficients_544() {
         assert_eq!(
-            [40.58f64, -0.036f64, 0f64],
-            Atlas::RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kallichore::declination_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_615() {
-        assert_eq!([83.53f64, -0.004f64, 0f64], Atlas::DECLINATION_COEFFICIENTS)
+    fn test_rotational_elements_prime_meridian_coefficients_544() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kallichore::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_615() {
+    fn test_naif_id_545() {
+        assert_eq!(Helike::id(), 545i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_545() {
         assert_eq!(
-            [137.88f64, 598.306f64, 0f64],
-            Atlas::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Helike::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_616() {
-        assert_eq!(Prometheus::id(), 616i32)
+    fn test_rotational_elements_right_ascension_coefficients_545() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Helike::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_point_mass_616() {
-        assert_eq!(Prometheus::gravitational_parameter(), 0.0107520800100761f64);
+    fn test_rotational_elements_declination_coefficients_545() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Helike::declination_coefficients()
+        )
     }
     #[test]
-    fn test_tri_axial_616() {
-        assert_eq!(Prometheus::polar_radius(), 28.2f64);
-        assert_eq!(Prometheus::mean_radius(), 46f64);
-        assert_eq!(Prometheus::subplanetary_radius(), 68.2f64);
-        assert_eq!(Prometheus::along_orbit_radius(), 41.6f64);
+    fn test_rotational_elements_prime_meridian_coefficients_545() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Helike::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_616() {
+    fn test_naif_id_546() {
+        assert_eq!(Carpo::id(), 546i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_546() {
         assert_eq!(
-            [40.58f64, -0.036f64, 0f64],
-            Prometheus::RIGHT_ASCENSION_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Carpo::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_616() {
+    fn test_rotational_elements_right_ascension_coefficients_546() {
         assert_eq!(
-            [83.53f64, -0.004f64, 0f64],
-            Prometheus::DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Carpo::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_616() {
+    fn test_rotational_elements_declination_coefficients_546() {
         assert_eq!(
-            [296.14f64, 587.289f64, 0f64],
-            Prometheus::PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Carpo::declination_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_617() {
-        assert_eq!(Pandora::id(), 617i32)
+    fn test_rotational_elements_prime_meridian_coefficients_546() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Carpo::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_point_mass_617() {
-        assert_eq!(Pandora::gravitational_parameter(), 0.009290325122028795f64);
+    fn test_naif_id_547() {
+        assert_eq!(Eukelade::id(), 547i32)
     }
     #[test]
-    fn test_tri_axial_617() {
-        assert_eq!(Pandora::polar_radius(), 31.5f64);
-        assert_eq!(Pandora::mean_radius(), 41.5f64);
-        assert_eq!(Pandora::subplanetary_radius(), 52.2f64);
-        assert_eq!(Pandora::along_orbit_radius(), 40.8f64);
+    fn test_rotational_elements_nutation_precession_coefficients_547() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Eukelade::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_617() {
+    fn test_rotational_elements_right_ascension_coefficients_547() {
         assert_eq!(
-            [40.58f64, -0.036f64, 0f64],
-            Pandora::RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Eukelade::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_617() {
+    fn test_rotational_elements_declination_coefficients_547() {
         assert_eq!(
-            [83.53f64, -0.004f64, 0f64],
-            Pandora::DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Eukelade::declination_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_617() {
+    fn test_rotational_elements_prime_meridian_coefficients_547() {
         assert_eq!(
-            [162.92f64, 572.7891f64, 0f64],
-            Pandora::PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Eukelade::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_618() {
-        assert_eq!(Pan::id(), 618i32)
+    fn test_naif_id_548() {
+        assert_eq!(Cyllene::id(), 548i32)
     }
     #[test]
-    fn test_tri_axial_618() {
-        assert_eq!(Pan::polar_radius(), 10.4f64);
-        assert_eq!(Pan::mean_radius(), 14.333333333333334f64);
-        assert_eq!(Pan::subplanetary_radius(), 17.2f64);
-        assert_eq!(Pan::along_orbit_radius(), 15.4f64);
+    fn test_rotational_elements_nutation_precession_coefficients_548() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Cyllene::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_618() {
+    fn test_rotational_elements_right_ascension_coefficients_548() {
         assert_eq!(
-            [40.6f64, -0.036f64, 0f64],
-            Pan::RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Cyllene::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_618() {
-        assert_eq!([83.5f64, -0.004f64, 0f64], Pan::DECLINATION_COEFFICIENTS)
+    fn test_rotational_elements_declination_coefficients_548() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Cyllene::declination_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_618() {
+    fn test_rotational_elements_prime_meridian_coefficients_548() {
         assert_eq!(
-            [48.8f64, 626.044f64, 0f64],
-            Pan::PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Cyllene::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_619() {
-        assert_eq!(Ymir::id(), 619i32)
+    fn test_naif_id_549() {
+        assert_eq!(Kore::id(), 549i32)
     }
     #[test]
-    fn test_naif_id_620() {
-        assert_eq!(Paaliaq::id(), 620i32)
+    fn test_rotational_elements_nutation_precession_coefficients_549() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Kore::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_621() {
-        assert_eq!(Tarvos::id(), 621i32)
+    fn test_rotational_elements_right_ascension_coefficients_549() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kore::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_622() {
-        assert_eq!(Ijiraq::id(), 622i32)
+    fn test_rotational_elements_declination_coefficients_549() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kore::declination_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_623() {
-        assert_eq!(Suttungr::id(), 623i32)
+    fn test_rotational_elements_prime_meridian_coefficients_549() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kore::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_624() {
-        assert_eq!(Kiviuq::id(), 624i32)
+    fn test_naif_id_550() {
+        assert_eq!(Herse::id(), 550i32)
     }
     #[test]
-    fn test_naif_id_625() {
-        assert_eq!(Mundilfari::id(), 625i32)
+    fn test_rotational_elements_nutation_precession_coefficients_550() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Herse::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_626() {
-        assert_eq!(Albiorix::id(), 626i32)
+    fn test_rotational_elements_right_ascension_coefficients_550() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Herse::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_627() {
-        assert_eq!(Skathi::id(), 627i32)
+    fn test_rotational_elements_declination_coefficients_550() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Herse::declination_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_628() {
-        assert_eq!(Erriapus::id(), 628i32)
+    fn test_rotational_elements_prime_meridian_coefficients_550() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Herse::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_629() {
-        assert_eq!(Siarnaq::id(), 629i32)
+    fn test_naif_id_553() {
+        assert_eq!(Dia::id(), 553i32)
     }
     #[test]
-    fn test_naif_id_630() {
-        assert_eq!(Thrymr::id(), 630i32)
+    fn test_rotational_elements_nutation_precession_coefficients_553() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Dia::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_631() {
-        assert_eq!(Narvi::id(), 631i32)
+    fn test_rotational_elements_right_ascension_coefficients_553() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Dia::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_632() {
-        assert_eq!(Methone::id(), 632i32)
+    fn test_rotational_elements_declination_coefficients_553() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Dia::declination_coefficients()
+        )
     }
     #[test]
-    fn test_tri_axial_632() {
-        assert_eq!(Methone::polar_radius(), 1.21f64);
-        assert_eq!(Methone::mean_radius(), 1.4799999999999998f64);
-        assert_eq!(Methone::subplanetary_radius(), 1.94f64);
-        assert_eq!(Methone::along_orbit_radius(), 1.29f64);
+    fn test_rotational_elements_prime_meridian_coefficients_553() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Dia::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_633() {
-        assert_eq!(Pallene::id(), 633i32)
+    fn test_naif_id_601() {
+        assert_eq!(Mimas::id(), 601i32)
     }
     #[test]
-    fn test_tri_axial_633() {
-        assert_eq!(Pallene::polar_radius(), 1.8f64);
-        assert_eq!(Pallene::mean_radius(), 2.2533333333333334f64);
-        assert_eq!(Pallene::subplanetary_radius(), 2.88f64);
-        assert_eq!(Pallene::along_orbit_radius(), 2.08f64);
+    fn test_point_mass_601() {
+        assert_eq!(Mimas::gravitational_parameter(), 2.503488768152587f64);
     }
     #[test]
-    fn test_naif_id_634() {
-        assert_eq!(Polydeuces::id(), 634i32)
+    fn test_tri_axial_601() {
+        assert_eq!(Mimas::polar_radius(), 190.6f64);
+        assert_eq!(Mimas::mean_radius(), 198.36666666666667f64);
+        assert_eq!(Mimas::subplanetary_radius(), 207.8f64);
+        assert_eq!(Mimas::along_orbit_radius(), 196.7f64);
     }
     #[test]
-    fn test_tri_axial_634() {
-        assert_eq!(Polydeuces::polar_radius(), 1f64);
-        assert_eq!(Polydeuces::mean_radius(), 1.2333333333333334f64);
-        assert_eq!(Polydeuces::subplanetary_radius(), 1.5f64);
-        assert_eq!(Polydeuces::along_orbit_radius(), 1.2f64);
+    fn test_rotational_elements_nutation_precession_coefficients_601() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Mimas::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_635() {
-        assert_eq!(Daphnis::id(), 635i32)
+    fn test_rotational_elements_right_ascension_coefficients_601() {
+        assert_eq!(
+            (
+                40.66f64,
+                -0.036f64,
+                0f64,
+                &[0f64, 0f64, 13.56f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64]
+            ),
+            Mimas::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_tri_axial_635() {
-        assert_eq!(Daphnis::polar_radius(), 2.8f64);
-        assert_eq!(Daphnis::mean_radius(), 3.9666666666666663f64);
-        assert_eq!(Daphnis::subplanetary_radius(), 4.6f64);
-        assert_eq!(Daphnis::along_orbit_radius(), 4.5f64);
+    fn test_rotational_elements_declination_coefficients_601() {
+        assert_eq!(
+            (
+                83.52f64,
+                -0.004f64,
+                0f64,
+                &[0f64, 0f64, -1.53f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64]
+            ),
+            Mimas::declination_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_636() {
-        assert_eq!(Aegir::id(), 636i32)
+    fn test_rotational_elements_prime_meridian_coefficients_601() {
+        assert_eq!(
+            (
+                333.46f64,
+                381.994555f64,
+                0f64,
+                &[0f64, 0f64, -13.48f64, 0f64, -44.85f64, 0f64, 0f64, 0f64] as &[f64]
+            ),
+            Mimas::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_637() {
-        assert_eq!(Bebhionn::id(), 637i32)
+    fn test_naif_id_602() {
+        assert_eq!(Enceladus::id(), 602i32)
     }
     #[test]
-    fn test_naif_id_638() {
-        assert_eq!(Bergelmir::id(), 638i32)
+    fn test_point_mass_602() {
+        assert_eq!(Enceladus::gravitational_parameter(), 7.210366688598896f64);
     }
     #[test]
-    fn test_naif_id_639() {
-        assert_eq!(Bestla::id(), 639i32)
+    fn test_tri_axial_602() {
+        assert_eq!(Enceladus::polar_radius(), 248.3f64);
+        assert_eq!(Enceladus::mean_radius(), 252.1f64);
+        assert_eq!(Enceladus::subplanetary_radius(), 256.6f64);
+        assert_eq!(Enceladus::along_orbit_radius(), 251.4f64);
     }
     #[test]
-    fn test_naif_id_640() {
-        assert_eq!(Farbauti::id(), 640i32)
+    fn test_rotational_elements_nutation_precession_coefficients_602() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Enceladus::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_641() {
-        assert_eq!(Fenrir::id(), 641i32)
+    fn test_rotational_elements_right_ascension_coefficients_602() {
+        assert_eq!(
+            (40.66f64, -0.036f64, 0f64, &[] as &[f64]),
+            Enceladus::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_642() {
-        assert_eq!(Fornjot::id(), 642i32)
+    fn test_rotational_elements_declination_coefficients_602() {
+        assert_eq!(
+            (83.52f64, -0.004f64, 0f64, &[] as &[f64]),
+            Enceladus::declination_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_643() {
-        assert_eq!(Hati::id(), 643i32)
+    fn test_rotational_elements_prime_meridian_coefficients_602() {
+        assert_eq!(
+            (6.32f64, 262.7318996f64, 0f64, &[] as &[f64]),
+            Enceladus::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_644() {
-        assert_eq!(Hyrrokkin::id(), 644i32)
+    fn test_naif_id_603() {
+        assert_eq!(Tethys::id(), 603i32)
     }
     #[test]
-    fn test_naif_id_645() {
-        assert_eq!(Kari::id(), 645i32)
+    fn test_point_mass_603() {
+        assert_eq!(Tethys::gravitational_parameter(), 41.21352885489587f64);
     }
     #[test]
-    fn test_naif_id_646() {
-        assert_eq!(Loge::id(), 646i32)
+    fn test_tri_axial_603() {
+        assert_eq!(Tethys::polar_radius(), 526.3f64);
+        assert_eq!(Tethys::mean_radius(), 530.9999999999999f64);
+        assert_eq!(Tethys::subplanetary_radius(), 538.4f64);
+        assert_eq!(Tethys::along_orbit_radius(), 528.3f64);
     }
     #[test]
-    fn test_naif_id_647() {
-        assert_eq!(Skoll::id(), 647i32)
+    fn test_rotational_elements_nutation_precession_coefficients_603() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Tethys::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_648() {
-        assert_eq!(Surtur::id(), 648i32)
+    fn test_rotational_elements_right_ascension_coefficients_603() {
+        assert_eq!(
+            (
+                40.66f64,
+                -0.036f64,
+                0f64,
+                &[0f64, 0f64, 0f64, 9.66f64, 0f64, 0f64, 0f64, 0f64] as &[f64]
+            ),
+            Tethys::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_649() {
-        assert_eq!(Anthe::id(), 649i32)
+    fn test_rotational_elements_declination_coefficients_603() {
+        assert_eq!(
+            (
+                83.52f64,
+                -0.004f64,
+                0f64,
+                &[0f64, 0f64, 0f64, -1.09f64, 0f64, 0f64, 0f64, 0f64] as &[f64]
+            ),
+            Tethys::declination_coefficients()
+        )
     }
     #[test]
-    fn test_tri_axial_649() {
-        assert_eq!(Anthe::polar_radius(), 0.5f64);
-        assert_eq!(Anthe::mean_radius(), 0.5f64);
-        assert_eq!(Anthe::subplanetary_radius(), 0.5f64);
-        assert_eq!(Anthe::along_orbit_radius(), 0.5f64);
+    fn test_rotational_elements_prime_meridian_coefficients_603() {
+        assert_eq!(
+            (
+                8.95f64,
+                190.6979085f64,
+                0f64,
+                &[0f64, 0f64, 0f64, -9.6f64, 2.23f64, 0f64, 0f64, 0f64] as &[f64]
+            ),
+            Tethys::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_650() {
-        assert_eq!(Jarnsaxa::id(), 650i32)
+    fn test_naif_id_604() {
+        assert_eq!(Dione::id(), 604i32)
     }
     #[test]
-    fn test_naif_id_651() {
-        assert_eq!(Greip::id(), 651i32)
+    fn test_point_mass_604() {
+        assert_eq!(Dione::gravitational_parameter(), 73.11607172482067f64);
     }
     #[test]
-    fn test_naif_id_652() {
-        assert_eq!(Tarqeq::id(), 652i32)
+    fn test_tri_axial_604() {
+        assert_eq!(Dione::polar_radius(), 559.6f64);
+        assert_eq!(Dione::mean_radius(), 561.4333333333333f64);
+        assert_eq!(Dione::subplanetary_radius(), 563.4f64);
+        assert_eq!(Dione::along_orbit_radius(), 561.3f64);
     }
     #[test]
-    fn test_naif_id_653() {
-        assert_eq!(Aegaeon::id(), 653i32)
+    fn test_rotational_elements_nutation_precession_coefficients_604() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Dione::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_tri_axial_653() {
-        assert_eq!(Aegaeon::polar_radius(), 0.2f64);
-        assert_eq!(Aegaeon::mean_radius(), 0.3833333333333333f64);
-        assert_eq!(Aegaeon::subplanetary_radius(), 0.7f64);
-        assert_eq!(Aegaeon::along_orbit_radius(), 0.25f64);
+    fn test_rotational_elements_right_ascension_coefficients_604() {
+        assert_eq!(
+            (40.66f64, -0.036f64, 0f64, &[] as &[f64]),
+            Dione::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_701() {
-        assert_eq!(Ariel::id(), 701i32)
+    fn test_rotational_elements_declination_coefficients_604() {
+        assert_eq!(
+            (83.52f64, -0.004f64, 0f64, &[] as &[f64]),
+            Dione::declination_coefficients()
+        )
     }
     #[test]
-    fn test_point_mass_701() {
-        assert_eq!(Ariel::gravitational_parameter(), 83.46344431770477f64);
+    fn test_rotational_elements_prime_meridian_coefficients_604() {
+        assert_eq!(
+            (357.6f64, 131.5349316f64, 0f64, &[] as &[f64]),
+            Dione::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_tri_axial_701() {
-        assert_eq!(Ariel::polar_radius(), 577.7f64);
-        assert_eq!(Ariel::mean_radius(), 578.9f64);
-        assert_eq!(Ariel::subplanetary_radius(), 581.1f64);
-        assert_eq!(Ariel::along_orbit_radius(), 577.9f64);
+    fn test_naif_id_605() {
+        assert_eq!(Rhea::id(), 605i32)
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_701() {
-        assert_eq!([257.43f64, 0f64, 0f64], Ariel::RIGHT_ASCENSION_COEFFICIENTS)
+    fn test_point_mass_605() {
+        assert_eq!(Rhea::gravitational_parameter(), 153.9417519146563f64);
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_701() {
-        assert_eq!([-15.1f64, 0f64, 0f64], Ariel::DECLINATION_COEFFICIENTS)
+    fn test_tri_axial_605() {
+        assert_eq!(Rhea::polar_radius(), 762.4f64);
+        assert_eq!(Rhea::mean_radius(), 763.5f64);
+        assert_eq!(Rhea::subplanetary_radius(), 765f64);
+        assert_eq!(Rhea::along_orbit_radius(), 763.1f64);
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_701() {
+    fn test_rotational_elements_nutation_precession_coefficients_605() {
         assert_eq!(
-            [156.22f64, -142.8356681f64, 0f64],
-            Ariel::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Rhea::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients701() {
+    fn test_rotational_elements_right_ascension_coefficients_605() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.29f64],
-            Ariel::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                40.38f64,
+                -0.036f64,
+                0f64,
+                &[0f64, 0f64, 0f64, 0f64, 0f64, 3.1f64, 0f64, 0f64] as &[f64]
+            ),
+            Rhea::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients701() {
+    fn test_rotational_elements_declination_coefficients_605() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.28f64],
-            Ariel::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                83.55f64,
+                -0.004f64,
+                0f64,
+                &[0f64, 0f64, 0f64, 0f64, 0f64, -0.35f64, 0f64, 0f64] as &[f64]
+            ),
+            Rhea::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients701() {
+    fn test_rotational_elements_prime_meridian_coefficients_605() {
         assert_eq!(
-            &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.05f64, 0.08f64],
-            Ariel::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                235.16f64,
+                79.6900478f64,
+                0f64,
+                &[0f64, 0f64, 0f64, 0f64, 0f64, -3.08f64, 0f64, 0f64] as &[f64]
+            ),
+            Rhea::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_702() {
-        assert_eq!(Umbriel::id(), 702i32)
-    }
-    #[test]
-    fn test_point_mass_702() {
-        assert_eq!(Umbriel::gravitational_parameter(), 85.09338094489388f64);
-    }
-    #[test]
-    fn test_tri_axial_702() {
-        assert_eq!(Umbriel::polar_radius(), 584.7f64);
-        assert_eq!(Umbriel::mean_radius(), 584.7f64);
-        assert_eq!(Umbriel::subplanetary_radius(), 584.7f64);
-        assert_eq!(Umbriel::along_orbit_radius(), 584.7f64);
+    fn test_naif_id_606() {
+        assert_eq!(Titan::id(), 606i32)
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_702() {
-        assert_eq!(
-            [257.43f64, 0f64, 0f64],
-            Umbriel::RIGHT_ASCENSION_COEFFICIENTS
-        )
+    fn test_point_mass_606() {
+        assert_eq!(Titan::gravitational_parameter(), 8978.137095521046f64);
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_702() {
-        assert_eq!([-15.1f64, 0f64, 0f64], Umbriel::DECLINATION_COEFFICIENTS)
+    fn test_tri_axial_606() {
+        assert_eq!(Titan::polar_radius(), 2574.47f64);
+        assert_eq!(Titan::mean_radius(), 2574.7999999999997f64);
+        assert_eq!(Titan::subplanetary_radius(), 2575.15f64);
+        assert_eq!(Titan::along_orbit_radius(), 2574.78f64);
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_702() {
+    fn test_rotational_elements_nutation_precession_coefficients_606() {
         assert_eq!(
-            [108.05f64, -86.8688923f64, 0f64],
-            Umbriel::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Titan::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients702() {
+    fn test_rotational_elements_right_ascension_coefficients_606() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0.21f64
-            ],
-            Umbriel::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                39.4827f64,
+                0f64,
+                0f64,
+                &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64]
+            ),
+            Titan::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients702() {
+    fn test_rotational_elements_declination_coefficients_606() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0.2f64
-            ],
-            Umbriel::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                83.4279f64,
+                0f64,
+                0f64,
+                &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64]
+            ),
+            Titan::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients702() {
+    fn test_rotational_elements_prime_meridian_coefficients_606() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.09f64, 0f64,
-                0.06f64
-            ],
-            Umbriel::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                186.5855f64,
+                22.5769768f64,
+                0f64,
+                &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64]
+            ),
+            Titan::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_703() {
-        assert_eq!(Titania::id(), 703i32)
+    fn test_naif_id_607() {
+        assert_eq!(Hyperion::id(), 607i32)
     }
     #[test]
-    fn test_point_mass_703() {
-        assert_eq!(Titania::gravitational_parameter(), 226.9437003741248f64);
+    fn test_point_mass_607() {
+        assert_eq!(Hyperion::gravitational_parameter(), 0.3704913747932265f64);
     }
     #[test]
-    fn test_tri_axial_703() {
-        assert_eq!(Titania::polar_radius(), 788.9f64);
+    fn test_tri_axial_607() {
+        assert_eq!(Hyperion::polar_radius(), 102.7f64);
+        assert_eq!(Hyperion::mean_radius(), 138.6f64);
+        assert_eq!(Hyperion::subplanetary_radius(), 180.1f64);
+        assert_eq!(Hyperion::along_orbit_radius(), 133f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_607() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Hyperion::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_607() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Hyperion::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_607() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Hyperion::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_607() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Hyperion::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_608() {
+        assert_eq!(Iapetus::id(), 608i32)
+    }
+    #[test]
+    fn test_point_mass_608() {
+        assert_eq!(Iapetus::gravitational_parameter(), 120.5151060137642f64);
+    }
+    #[test]
+    fn test_tri_axial_608() {
+        assert_eq!(Iapetus::polar_radius(), 712.1f64);
+        assert_eq!(Iapetus::mean_radius(), 734.5f64);
+        assert_eq!(Iapetus::subplanetary_radius(), 745.7f64);
+        assert_eq!(Iapetus::along_orbit_radius(), 745.7f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_608() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Iapetus::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_608() {
+        assert_eq!(
+            (318.16f64, -3.949f64, 0f64, &[] as &[f64]),
+            Iapetus::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_608() {
+        assert_eq!(
+            (75.03f64, -1.143f64, 0f64, &[] as &[f64]),
+            Iapetus::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_608() {
+        assert_eq!(
+            (355.2f64, 4.5379572f64, 0f64, &[] as &[f64]),
+            Iapetus::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_609() {
+        assert_eq!(Phoebe::id(), 609i32)
+    }
+    #[test]
+    fn test_point_mass_609() {
+        assert_eq!(Phoebe::gravitational_parameter(), 0.5547860052791678f64);
+    }
+    #[test]
+    fn test_tri_axial_609() {
+        assert_eq!(Phoebe::polar_radius(), 101.8f64);
+        assert_eq!(Phoebe::mean_radius(), 106.56666666666666f64);
+        assert_eq!(Phoebe::subplanetary_radius(), 109.4f64);
+        assert_eq!(Phoebe::along_orbit_radius(), 108.5f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_609() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Phoebe::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_609() {
+        assert_eq!(
+            (356.9f64, 0f64, 0f64, &[] as &[f64]),
+            Phoebe::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_609() {
+        assert_eq!(
+            (77.8f64, 0f64, 0f64, &[] as &[f64]),
+            Phoebe::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_609() {
+        assert_eq!(
+            (178.58f64, 931.639f64, 0f64, &[] as &[f64]),
+            Phoebe::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_610() {
+        assert_eq!(Janus::id(), 610i32)
+    }
+    #[test]
+    fn test_point_mass_610() {
+        assert_eq!(Janus::gravitational_parameter(), 0.1265765099012197f64);
+    }
+    #[test]
+    fn test_tri_axial_610() {
+        assert_eq!(Janus::polar_radius(), 76.3f64);
+        assert_eq!(Janus::mean_radius(), 90.33333333333333f64);
+        assert_eq!(Janus::subplanetary_radius(), 101.7f64);
+        assert_eq!(Janus::along_orbit_radius(), 93f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_610() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Janus::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_610() {
+        assert_eq!(
+            (
+                40.58f64,
+                -0.036f64,
+                0f64,
+                &[0f64, -1.623f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.023f64] as &[f64]
+            ),
+            Janus::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_610() {
+        assert_eq!(
+            (
+                83.52f64,
+                -0.004f64,
+                0f64,
+                &[0f64, -0.183f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.001f64] as &[f64]
+            ),
+            Janus::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_610() {
+        assert_eq!(
+            (
+                58.83f64,
+                518.2359876f64,
+                0f64,
+                &[0f64, 1.613f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.023f64] as &[f64]
+            ),
+            Janus::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_611() {
+        assert_eq!(Epimetheus::id(), 611i32)
+    }
+    #[test]
+    fn test_point_mass_611() {
+        assert_eq!(
+            Epimetheus::gravitational_parameter(),
+            0.03512333288208074f64
+        );
+    }
+    #[test]
+    fn test_tri_axial_611() {
+        assert_eq!(Epimetheus::polar_radius(), 53f64);
+        assert_eq!(Epimetheus::mean_radius(), 58.4f64);
+        assert_eq!(Epimetheus::subplanetary_radius(), 64.9f64);
+        assert_eq!(Epimetheus::along_orbit_radius(), 57.3f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_611() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Epimetheus::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_611() {
+        assert_eq!(
+            (
+                40.58f64,
+                -0.036f64,
+                0f64,
+                &[-3.153f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.086f64, 0f64] as &[f64]
+            ),
+            Epimetheus::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_611() {
+        assert_eq!(
+            (
+                83.52f64,
+                -0.004f64,
+                0f64,
+                &[-0.356f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.005f64, 0f64] as &[f64]
+            ),
+            Epimetheus::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_611() {
+        assert_eq!(
+            (
+                293.87f64,
+                518.4907239f64,
+                0f64,
+                &[3.133f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.086f64, 0f64] as &[f64]
+            ),
+            Epimetheus::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_612() {
+        assert_eq!(Helene::id(), 612i32)
+    }
+    #[test]
+    fn test_point_mass_612() {
+        assert_eq!(Helene::gravitational_parameter(), 0.0004757419551776972f64);
+    }
+    #[test]
+    fn test_tri_axial_612() {
+        assert_eq!(Helene::polar_radius(), 13.3f64);
+        assert_eq!(Helene::mean_radius(), 18.46666666666667f64);
+        assert_eq!(Helene::subplanetary_radius(), 22.5f64);
+        assert_eq!(Helene::along_orbit_radius(), 19.6f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_612() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Helene::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_612() {
+        assert_eq!(
+            (40.85f64, -0.036f64, 0f64, &[] as &[f64]),
+            Helene::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_612() {
+        assert_eq!(
+            (83.34f64, -0.004f64, 0f64, &[] as &[f64]),
+            Helene::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_612() {
+        assert_eq!(
+            (245.12f64, 131.6174056f64, 0f64, &[] as &[f64]),
+            Helene::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_613() {
+        assert_eq!(Telesto::id(), 613i32)
+    }
+    #[test]
+    fn test_tri_axial_613() {
+        assert_eq!(Telesto::polar_radius(), 9.8f64);
+        assert_eq!(Telesto::mean_radius(), 12.633333333333335f64);
+        assert_eq!(Telesto::subplanetary_radius(), 16.3f64);
+        assert_eq!(Telesto::along_orbit_radius(), 11.8f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_613() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Telesto::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_613() {
+        assert_eq!(
+            (50.51f64, -0.036f64, 0f64, &[] as &[f64]),
+            Telesto::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_613() {
+        assert_eq!(
+            (84.06f64, -0.004f64, 0f64, &[] as &[f64]),
+            Telesto::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_613() {
+        assert_eq!(
+            (56.88f64, 190.6979332f64, 0f64, &[] as &[f64]),
+            Telesto::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_614() {
+        assert_eq!(Calypso::id(), 614i32)
+    }
+    #[test]
+    fn test_tri_axial_614() {
+        assert_eq!(Calypso::polar_radius(), 6.3f64);
+        assert_eq!(Calypso::mean_radius(), 10.3f64);
+        assert_eq!(Calypso::subplanetary_radius(), 15.3f64);
+        assert_eq!(Calypso::along_orbit_radius(), 9.3f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_614() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Calypso::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_614() {
+        assert_eq!(
+            (36.41f64, -0.036f64, 0f64, &[] as &[f64]),
+            Calypso::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_614() {
+        assert_eq!(
+            (85.04f64, -0.004f64, 0f64, &[] as &[f64]),
+            Calypso::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_614() {
+        assert_eq!(
+            (153.51f64, 190.6742373f64, 0f64, &[] as &[f64]),
+            Calypso::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_615() {
+        assert_eq!(Atlas::id(), 615i32)
+    }
+    #[test]
+    fn test_point_mass_615() {
+        assert_eq!(Atlas::gravitational_parameter(), 0.0003718871247516475f64);
+    }
+    #[test]
+    fn test_tri_axial_615() {
+        assert_eq!(Atlas::polar_radius(), 9.4f64);
+        assert_eq!(Atlas::mean_radius(), 15.899999999999999f64);
+        assert_eq!(Atlas::subplanetary_radius(), 20.5f64);
+        assert_eq!(Atlas::along_orbit_radius(), 17.8f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_615() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Atlas::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_615() {
+        assert_eq!(
+            (40.58f64, -0.036f64, 0f64, &[] as &[f64]),
+            Atlas::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_615() {
+        assert_eq!(
+            (83.53f64, -0.004f64, 0f64, &[] as &[f64]),
+            Atlas::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_615() {
+        assert_eq!(
+            (137.88f64, 598.306f64, 0f64, &[] as &[f64]),
+            Atlas::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_616() {
+        assert_eq!(Prometheus::id(), 616i32)
+    }
+    #[test]
+    fn test_point_mass_616() {
+        assert_eq!(Prometheus::gravitational_parameter(), 0.0107520800100761f64);
+    }
+    #[test]
+    fn test_tri_axial_616() {
+        assert_eq!(Prometheus::polar_radius(), 28.2f64);
+        assert_eq!(Prometheus::mean_radius(), 46f64);
+        assert_eq!(Prometheus::subplanetary_radius(), 68.2f64);
+        assert_eq!(Prometheus::along_orbit_radius(), 41.6f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_616() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Prometheus::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_616() {
+        assert_eq!(
+            (40.58f64, -0.036f64, 0f64, &[] as &[f64]),
+            Prometheus::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_616() {
+        assert_eq!(
+            (83.53f64, -0.004f64, 0f64, &[] as &[f64]),
+            Prometheus::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_616() {
+        assert_eq!(
+            (296.14f64, 587.289f64, 0f64, &[] as &[f64]),
+            Prometheus::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_617() {
+        assert_eq!(Pandora::id(), 617i32)
+    }
+    #[test]
+    fn test_point_mass_617() {
+        assert_eq!(Pandora::gravitational_parameter(), 0.009290325122028795f64);
+    }
+    #[test]
+    fn test_tri_axial_617() {
+        assert_eq!(Pandora::polar_radius(), 31.5f64);
+        assert_eq!(Pandora::mean_radius(), 41.5f64);
+        assert_eq!(Pandora::subplanetary_radius(), 52.2f64);
+        assert_eq!(Pandora::along_orbit_radius(), 40.8f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_617() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Pandora::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_617() {
+        assert_eq!(
+            (40.58f64, -0.036f64, 0f64, &[] as &[f64]),
+            Pandora::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_617() {
+        assert_eq!(
+            (83.53f64, -0.004f64, 0f64, &[] as &[f64]),
+            Pandora::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_617() {
+        assert_eq!(
+            (162.92f64, 572.7891f64, 0f64, &[] as &[f64]),
+            Pandora::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_618() {
+        assert_eq!(Pan::id(), 618i32)
+    }
+    #[test]
+    fn test_tri_axial_618() {
+        assert_eq!(Pan::polar_radius(), 10.4f64);
+        assert_eq!(Pan::mean_radius(), 14.333333333333334f64);
+        assert_eq!(Pan::subplanetary_radius(), 17.2f64);
+        assert_eq!(Pan::along_orbit_radius(), 15.4f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_618() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Pan::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_618() {
+        assert_eq!(
+            (40.6f64, -0.036f64, 0f64, &[] as &[f64]),
+            Pan::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_618() {
+        assert_eq!(
+            (83.5f64, -0.004f64, 0f64, &[] as &[f64]),
+            Pan::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_618() {
+        assert_eq!(
+            (48.8f64, 626.044f64, 0f64, &[] as &[f64]),
+            Pan::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_619() {
+        assert_eq!(Ymir::id(), 619i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_619() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Ymir::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_619() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Ymir::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_619() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Ymir::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_619() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Ymir::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_620() {
+        assert_eq!(Paaliaq::id(), 620i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_620() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Paaliaq::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_620() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Paaliaq::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_620() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Paaliaq::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_620() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Paaliaq::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_621() {
+        assert_eq!(Tarvos::id(), 621i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_621() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Tarvos::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_621() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Tarvos::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_621() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Tarvos::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_621() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Tarvos::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_622() {
+        assert_eq!(Ijiraq::id(), 622i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_622() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Ijiraq::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_622() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Ijiraq::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_622() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Ijiraq::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_622() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Ijiraq::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_623() {
+        assert_eq!(Suttungr::id(), 623i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_623() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Suttungr::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_623() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Suttungr::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_623() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Suttungr::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_623() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Suttungr::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_624() {
+        assert_eq!(Kiviuq::id(), 624i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_624() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Kiviuq::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_624() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kiviuq::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_624() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kiviuq::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_624() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kiviuq::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_625() {
+        assert_eq!(Mundilfari::id(), 625i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_625() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Mundilfari::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_625() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Mundilfari::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_625() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Mundilfari::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_625() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Mundilfari::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_626() {
+        assert_eq!(Albiorix::id(), 626i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_626() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Albiorix::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_626() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Albiorix::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_626() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Albiorix::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_626() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Albiorix::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_627() {
+        assert_eq!(Skathi::id(), 627i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_627() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Skathi::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_627() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Skathi::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_627() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Skathi::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_627() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Skathi::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_628() {
+        assert_eq!(Erriapus::id(), 628i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_628() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Erriapus::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_628() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Erriapus::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_628() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Erriapus::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_628() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Erriapus::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_629() {
+        assert_eq!(Siarnaq::id(), 629i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_629() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Siarnaq::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_629() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Siarnaq::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_629() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Siarnaq::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_629() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Siarnaq::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_630() {
+        assert_eq!(Thrymr::id(), 630i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_630() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Thrymr::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_630() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Thrymr::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_630() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Thrymr::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_630() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Thrymr::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_631() {
+        assert_eq!(Narvi::id(), 631i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_631() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Narvi::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_631() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Narvi::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_631() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Narvi::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_631() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Narvi::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_632() {
+        assert_eq!(Methone::id(), 632i32)
+    }
+    #[test]
+    fn test_tri_axial_632() {
+        assert_eq!(Methone::polar_radius(), 1.21f64);
+        assert_eq!(Methone::mean_radius(), 1.4799999999999998f64);
+        assert_eq!(Methone::subplanetary_radius(), 1.94f64);
+        assert_eq!(Methone::along_orbit_radius(), 1.29f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_632() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Methone::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_632() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Methone::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_632() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Methone::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_632() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Methone::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_633() {
+        assert_eq!(Pallene::id(), 633i32)
+    }
+    #[test]
+    fn test_tri_axial_633() {
+        assert_eq!(Pallene::polar_radius(), 1.8f64);
+        assert_eq!(Pallene::mean_radius(), 2.2533333333333334f64);
+        assert_eq!(Pallene::subplanetary_radius(), 2.88f64);
+        assert_eq!(Pallene::along_orbit_radius(), 2.08f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_633() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Pallene::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_633() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Pallene::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_633() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Pallene::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_633() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Pallene::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_634() {
+        assert_eq!(Polydeuces::id(), 634i32)
+    }
+    #[test]
+    fn test_tri_axial_634() {
+        assert_eq!(Polydeuces::polar_radius(), 1f64);
+        assert_eq!(Polydeuces::mean_radius(), 1.2333333333333334f64);
+        assert_eq!(Polydeuces::subplanetary_radius(), 1.5f64);
+        assert_eq!(Polydeuces::along_orbit_radius(), 1.2f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_634() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Polydeuces::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_634() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Polydeuces::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_634() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Polydeuces::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_634() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Polydeuces::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_635() {
+        assert_eq!(Daphnis::id(), 635i32)
+    }
+    #[test]
+    fn test_tri_axial_635() {
+        assert_eq!(Daphnis::polar_radius(), 2.8f64);
+        assert_eq!(Daphnis::mean_radius(), 3.9666666666666663f64);
+        assert_eq!(Daphnis::subplanetary_radius(), 4.6f64);
+        assert_eq!(Daphnis::along_orbit_radius(), 4.5f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_635() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Daphnis::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_635() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Daphnis::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_635() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Daphnis::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_635() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Daphnis::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_636() {
+        assert_eq!(Aegir::id(), 636i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_636() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Aegir::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_636() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Aegir::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_636() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Aegir::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_636() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Aegir::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_637() {
+        assert_eq!(Bebhionn::id(), 637i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_637() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Bebhionn::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_637() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Bebhionn::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_637() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Bebhionn::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_637() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Bebhionn::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_638() {
+        assert_eq!(Bergelmir::id(), 638i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_638() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Bergelmir::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_638() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Bergelmir::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_638() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Bergelmir::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_638() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Bergelmir::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_639() {
+        assert_eq!(Bestla::id(), 639i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_639() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Bestla::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_639() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Bestla::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_639() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Bestla::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_639() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Bestla::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_640() {
+        assert_eq!(Farbauti::id(), 640i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_640() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Farbauti::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_640() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Farbauti::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_640() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Farbauti::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_640() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Farbauti::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_641() {
+        assert_eq!(Fenrir::id(), 641i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_641() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Fenrir::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_641() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Fenrir::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_641() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Fenrir::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_641() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Fenrir::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_642() {
+        assert_eq!(Fornjot::id(), 642i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_642() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Fornjot::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_642() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Fornjot::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_642() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Fornjot::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_642() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Fornjot::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_643() {
+        assert_eq!(Hati::id(), 643i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_643() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Hati::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_643() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Hati::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_643() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Hati::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_643() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Hati::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_644() {
+        assert_eq!(Hyrrokkin::id(), 644i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_644() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Hyrrokkin::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_644() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Hyrrokkin::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_644() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Hyrrokkin::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_644() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Hyrrokkin::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_645() {
+        assert_eq!(Kari::id(), 645i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_645() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Kari::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_645() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kari::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_645() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kari::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_645() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kari::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_646() {
+        assert_eq!(Loge::id(), 646i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_646() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Loge::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_646() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Loge::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_646() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Loge::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_646() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Loge::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_647() {
+        assert_eq!(Skoll::id(), 647i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_647() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Skoll::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_647() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Skoll::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_647() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Skoll::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_647() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Skoll::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_648() {
+        assert_eq!(Surtur::id(), 648i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_648() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Surtur::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_648() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Surtur::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_648() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Surtur::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_648() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Surtur::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_649() {
+        assert_eq!(Anthe::id(), 649i32)
+    }
+    #[test]
+    fn test_tri_axial_649() {
+        assert_eq!(Anthe::polar_radius(), 0.5f64);
+        assert_eq!(Anthe::mean_radius(), 0.5f64);
+        assert_eq!(Anthe::subplanetary_radius(), 0.5f64);
+        assert_eq!(Anthe::along_orbit_radius(), 0.5f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_649() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Anthe::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_649() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Anthe::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_649() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Anthe::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_649() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Anthe::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_650() {
+        assert_eq!(Jarnsaxa::id(), 650i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_650() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Jarnsaxa::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_650() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Jarnsaxa::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_650() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Jarnsaxa::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_650() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Jarnsaxa::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_651() {
+        assert_eq!(Greip::id(), 651i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_651() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Greip::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_651() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Greip::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_651() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Greip::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_651() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Greip::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_652() {
+        assert_eq!(Tarqeq::id(), 652i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_652() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Tarqeq::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_652() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Tarqeq::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_652() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Tarqeq::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_652() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Tarqeq::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_653() {
+        assert_eq!(Aegaeon::id(), 653i32)
+    }
+    #[test]
+    fn test_tri_axial_653() {
+        assert_eq!(Aegaeon::polar_radius(), 0.2f64);
+        assert_eq!(Aegaeon::mean_radius(), 0.3833333333333333f64);
+        assert_eq!(Aegaeon::subplanetary_radius(), 0.7f64);
+        assert_eq!(Aegaeon::along_orbit_radius(), 0.25f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_653() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Aegaeon::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_653() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Aegaeon::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_653() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Aegaeon::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_653() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Aegaeon::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_701() {
+        assert_eq!(Ariel::id(), 701i32)
+    }
+    #[test]
+    fn test_point_mass_701() {
+        assert_eq!(Ariel::gravitational_parameter(), 83.46344431770477f64);
+    }
+    #[test]
+    fn test_tri_axial_701() {
+        assert_eq!(Ariel::polar_radius(), 577.7f64);
+        assert_eq!(Ariel::mean_radius(), 578.9f64);
+        assert_eq!(Ariel::subplanetary_radius(), 581.1f64);
+        assert_eq!(Ariel::along_orbit_radius(), 577.9f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_701() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Ariel::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_701() {
+        assert_eq!(
+            (
+                257.43f64,
+                0f64,
+                0f64,
+                &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.29f64]
+                    as &[f64]
+            ),
+            Ariel::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_701() {
+        assert_eq!(
+            (
+                -15.1f64,
+                0f64,
+                0f64,
+                &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.28f64]
+                    as &[f64]
+            ),
+            Ariel::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_701() {
+        assert_eq!(
+            (
+                156.22f64,
+                -142.8356681f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.05f64,
+                    0.08f64
+                ] as &[f64]
+            ),
+            Ariel::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_702() {
+        assert_eq!(Umbriel::id(), 702i32)
+    }
+    #[test]
+    fn test_point_mass_702() {
+        assert_eq!(Umbriel::gravitational_parameter(), 85.09338094489388f64);
+    }
+    #[test]
+    fn test_tri_axial_702() {
+        assert_eq!(Umbriel::polar_radius(), 584.7f64);
+        assert_eq!(Umbriel::mean_radius(), 584.7f64);
+        assert_eq!(Umbriel::subplanetary_radius(), 584.7f64);
+        assert_eq!(Umbriel::along_orbit_radius(), 584.7f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_702() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Umbriel::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_702() {
+        assert_eq!(
+            (
+                257.43f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0.21f64
+                ] as &[f64]
+            ),
+            Umbriel::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_702() {
+        assert_eq!(
+            (
+                -15.1f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0.2f64
+                ] as &[f64]
+            ),
+            Umbriel::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_702() {
+        assert_eq!(
+            (
+                108.05f64,
+                -86.8688923f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.09f64,
+                    0f64, 0.06f64
+                ] as &[f64]
+            ),
+            Umbriel::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_703() {
+        assert_eq!(Titania::id(), 703i32)
+    }
+    #[test]
+    fn test_point_mass_703() {
+        assert_eq!(Titania::gravitational_parameter(), 226.9437003741248f64);
+    }
+    #[test]
+    fn test_tri_axial_703() {
+        assert_eq!(Titania::polar_radius(), 788.9f64);
         assert_eq!(Titania::mean_radius(), 788.9f64);
         assert_eq!(Titania::subplanetary_radius(), 788.9f64);
         assert_eq!(Titania::along_orbit_radius(), 788.9f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_703() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Titania::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_703() {
         assert_eq!(
-            [257.43f64, 0f64, 0f64],
-            Titania::RIGHT_ASCENSION_COEFFICIENTS
+            (
+                257.43f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0.29f64
+                ] as &[f64]
+            ),
+            Titania::right_ascension_coefficients()
         )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_703() {
-        assert_eq!([-15.1f64, 0f64, 0f64], Titania::DECLINATION_COEFFICIENTS)
+        assert_eq!(
+            (
+                -15.1f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0.28f64
+                ] as &[f64]
+            ),
+            Titania::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_703() {
+        assert_eq!(
+            (
+                77.74f64,
+                -41.3514316f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0.08f64
+                ] as &[f64]
+            ),
+            Titania::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_704() {
+        assert_eq!(Oberon::id(), 704i32)
+    }
+    #[test]
+    fn test_point_mass_704() {
+        assert_eq!(Oberon::gravitational_parameter(), 205.3234302535623f64);
+    }
+    #[test]
+    fn test_tri_axial_704() {
+        assert_eq!(Oberon::polar_radius(), 761.4f64);
+        assert_eq!(Oberon::mean_radius(), 761.4f64);
+        assert_eq!(Oberon::subplanetary_radius(), 761.4f64);
+        assert_eq!(Oberon::along_orbit_radius(), 761.4f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_704() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Oberon::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_704() {
+        assert_eq!(
+            (
+                257.43f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0.16f64
+                ] as &[f64]
+            ),
+            Oberon::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_704() {
+        assert_eq!(
+            (
+                -15.1f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0.16f64
+                ] as &[f64]
+            ),
+            Oberon::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_704() {
+        assert_eq!(
+            (
+                6.77f64,
+                -26.7394932f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0.04f64
+                ] as &[f64]
+            ),
+            Oberon::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_705() {
+        assert_eq!(Miranda::id(), 705i32)
+    }
+    #[test]
+    fn test_point_mass_705() {
+        assert_eq!(Miranda::gravitational_parameter(), 4.3195168992321f64);
+    }
+    #[test]
+    fn test_tri_axial_705() {
+        assert_eq!(Miranda::polar_radius(), 232.9f64);
+        assert_eq!(Miranda::mean_radius(), 235.83333333333334f64);
+        assert_eq!(Miranda::subplanetary_radius(), 240.4f64);
+        assert_eq!(Miranda::along_orbit_radius(), 234.2f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_705() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Miranda::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_705() {
+        assert_eq!(
+            (
+                257.43f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 4.41f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, -0.04f64, 0f64
+                ] as &[f64]
+            ),
+            Miranda::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_705() {
+        assert_eq!(
+            (
+                -15.08f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 4.25f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, -0.02f64, 0f64
+                ] as &[f64]
+            ),
+            Miranda::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_705() {
+        assert_eq!(
+            (
+                30.7f64,
+                -254.6906892f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 1.15f64, -1.27f64,
+                    0f64, 0f64, 0f64, 0f64, -0.09f64, 0.15f64
+                ] as &[f64]
+            ),
+            Miranda::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_706() {
+        assert_eq!(Cordelia::id(), 706i32)
+    }
+    #[test]
+    fn test_tri_axial_706() {
+        assert_eq!(Cordelia::polar_radius(), 13f64);
+        assert_eq!(Cordelia::mean_radius(), 13f64);
+        assert_eq!(Cordelia::subplanetary_radius(), 13f64);
+        assert_eq!(Cordelia::along_orbit_radius(), 13f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_706() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Cordelia::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_706() {
+        assert_eq!(
+            (
+                257.31f64,
+                0f64,
+                0f64,
+                &[
+                    -0.15f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Cordelia::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_706() {
+        assert_eq!(
+            (
+                -15.18f64,
+                0f64,
+                0f64,
+                &[
+                    0.14f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Cordelia::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_706() {
+        assert_eq!(
+            (
+                127.69f64,
+                -1074.520573f64,
+                0f64,
+                &[
+                    -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Cordelia::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_707() {
+        assert_eq!(Ophelia::id(), 707i32)
+    }
+    #[test]
+    fn test_tri_axial_707() {
+        assert_eq!(Ophelia::polar_radius(), 15f64);
+        assert_eq!(Ophelia::mean_radius(), 15f64);
+        assert_eq!(Ophelia::subplanetary_radius(), 15f64);
+        assert_eq!(Ophelia::along_orbit_radius(), 15f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_707() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Ophelia::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_707() {
+        assert_eq!(
+            (
+                257.31f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, -0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Ophelia::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_707() {
+        assert_eq!(
+            (
+                -15.18f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Ophelia::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_707() {
+        assert_eq!(
+            (
+                130.35f64,
+                -956.406815f64,
+                0f64,
+                &[
+                    0f64, -0.03f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Ophelia::prime_meridian_coefficients()
+        )
+    }
+    #[test]
+    fn test_naif_id_708() {
+        assert_eq!(Bianca::id(), 708i32)
+    }
+    #[test]
+    fn test_tri_axial_708() {
+        assert_eq!(Bianca::polar_radius(), 21f64);
+        assert_eq!(Bianca::mean_radius(), 21f64);
+        assert_eq!(Bianca::subplanetary_radius(), 21f64);
+        assert_eq!(Bianca::along_orbit_radius(), 21f64);
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_703() {
+    fn test_rotational_elements_nutation_precession_coefficients_708() {
         assert_eq!(
-            [77.74f64, -41.3514316f64, 0f64],
-            Titania::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Bianca::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients703() {
+    fn test_rotational_elements_right_ascension_coefficients_708() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0.29f64
-            ],
-            Titania::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                257.31f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, -0.16f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Bianca::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients703() {
+    fn test_rotational_elements_declination_coefficients_708() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0.28f64
-            ],
-            Titania::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                -15.18f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0.16f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Bianca::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients703() {
+    fn test_rotational_elements_prime_meridian_coefficients_708() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0.08f64
-            ],
-            Titania::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                105.46f64,
+                -828.391476f64,
+                0f64,
+                &[
+                    0f64, 0f64, -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Bianca::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_704() {
-        assert_eq!(Oberon::id(), 704i32)
-    }
-    #[test]
-    fn test_point_mass_704() {
-        assert_eq!(Oberon::gravitational_parameter(), 205.3234302535623f64);
-    }
-    #[test]
-    fn test_tri_axial_704() {
-        assert_eq!(Oberon::polar_radius(), 761.4f64);
-        assert_eq!(Oberon::mean_radius(), 761.4f64);
-        assert_eq!(Oberon::subplanetary_radius(), 761.4f64);
-        assert_eq!(Oberon::along_orbit_radius(), 761.4f64);
-    }
-    #[test]
-    fn test_rotational_elements_right_ascension_coefficients_704() {
-        assert_eq!(
-            [257.43f64, 0f64, 0f64],
-            Oberon::RIGHT_ASCENSION_COEFFICIENTS
-        )
+    fn test_naif_id_709() {
+        assert_eq!(Cressida::id(), 709i32)
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_704() {
-        assert_eq!([-15.1f64, 0f64, 0f64], Oberon::DECLINATION_COEFFICIENTS)
+    fn test_tri_axial_709() {
+        assert_eq!(Cressida::polar_radius(), 31f64);
+        assert_eq!(Cressida::mean_radius(), 31f64);
+        assert_eq!(Cressida::subplanetary_radius(), 31f64);
+        assert_eq!(Cressida::along_orbit_radius(), 31f64);
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_704() {
+    fn test_rotational_elements_nutation_precession_coefficients_709() {
         assert_eq!(
-            [6.77f64, -26.7394932f64, 0f64],
-            Oberon::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Cressida::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients704() {
+    fn test_rotational_elements_right_ascension_coefficients_709() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0.16f64
-            ],
-            Oberon::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                257.31f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Cressida::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients704() {
+    fn test_rotational_elements_declination_coefficients_709() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0.16f64
-            ],
-            Oberon::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                -15.18f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Cressida::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients704() {
+    fn test_rotational_elements_prime_meridian_coefficients_709() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0.04f64
-            ],
-            Oberon::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                59.16f64,
+                -776.581632f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, -0.01f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Cressida::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_705() {
-        assert_eq!(Miranda::id(), 705i32)
-    }
-    #[test]
-    fn test_point_mass_705() {
-        assert_eq!(Miranda::gravitational_parameter(), 4.3195168992321f64);
-    }
-    #[test]
-    fn test_tri_axial_705() {
-        assert_eq!(Miranda::polar_radius(), 232.9f64);
-        assert_eq!(Miranda::mean_radius(), 235.83333333333334f64);
-        assert_eq!(Miranda::subplanetary_radius(), 240.4f64);
-        assert_eq!(Miranda::along_orbit_radius(), 234.2f64);
-    }
-    #[test]
-    fn test_rotational_elements_right_ascension_coefficients_705() {
-        assert_eq!(
-            [257.43f64, 0f64, 0f64],
-            Miranda::RIGHT_ASCENSION_COEFFICIENTS
-        )
+    fn test_naif_id_710() {
+        assert_eq!(Desdemona::id(), 710i32)
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_705() {
-        assert_eq!([-15.08f64, 0f64, 0f64], Miranda::DECLINATION_COEFFICIENTS)
+    fn test_tri_axial_710() {
+        assert_eq!(Desdemona::polar_radius(), 27f64);
+        assert_eq!(Desdemona::mean_radius(), 27f64);
+        assert_eq!(Desdemona::subplanetary_radius(), 27f64);
+        assert_eq!(Desdemona::along_orbit_radius(), 27f64);
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_705() {
+    fn test_rotational_elements_nutation_precession_coefficients_710() {
         assert_eq!(
-            [30.7f64, -254.6906892f64, 0f64],
-            Miranda::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Desdemona::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients705() {
+    fn test_rotational_elements_right_ascension_coefficients_710() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 4.41f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, -0.04f64, 0f64
-            ],
-            Miranda::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                257.31f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, -0.17f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Desdemona::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients705() {
+    fn test_rotational_elements_declination_coefficients_710() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 4.25f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, -0.02f64, 0f64
-            ],
-            Miranda::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                -15.18f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0.16f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Desdemona::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients705() {
+    fn test_rotational_elements_prime_meridian_coefficients_710() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 1.15f64, -1.27f64,
-                0f64, 0f64, 0f64, 0f64, -0.09f64, 0.15f64
-            ],
-            Miranda::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                95.08f64,
+                -760.053169f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Desdemona::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_706() {
-        assert_eq!(Cordelia::id(), 706i32)
+    fn test_naif_id_711() {
+        assert_eq!(Juliet::id(), 711i32)
     }
     #[test]
-    fn test_tri_axial_706() {
-        assert_eq!(Cordelia::polar_radius(), 13f64);
-        assert_eq!(Cordelia::mean_radius(), 13f64);
-        assert_eq!(Cordelia::subplanetary_radius(), 13f64);
-        assert_eq!(Cordelia::along_orbit_radius(), 13f64);
+    fn test_tri_axial_711() {
+        assert_eq!(Juliet::polar_radius(), 42f64);
+        assert_eq!(Juliet::mean_radius(), 42f64);
+        assert_eq!(Juliet::subplanetary_radius(), 42f64);
+        assert_eq!(Juliet::along_orbit_radius(), 42f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_706() {
+    fn test_rotational_elements_nutation_precession_coefficients_711() {
         assert_eq!(
-            [257.31f64, 0f64, 0f64],
-            Cordelia::RIGHT_ASCENSION_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Juliet::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_706() {
-        assert_eq!([-15.18f64, 0f64, 0f64], Cordelia::DECLINATION_COEFFICIENTS)
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_706() {
+    fn test_rotational_elements_right_ascension_coefficients_711() {
         assert_eq!(
-            [127.69f64, -1074.520573f64, 0f64],
-            Cordelia::PRIME_MERIDIAN_COEFFICIENTS
+            (
+                257.31f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, -0.06f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Juliet::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients706() {
+    fn test_rotational_elements_declination_coefficients_711() {
         assert_eq!(
-            &[
-                -0.15f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Cordelia::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                -15.18f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0.06f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Juliet::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients706() {
+    fn test_rotational_elements_prime_meridian_coefficients_711() {
         assert_eq!(
-            &[
-                0.14f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Cordelia::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                302.56f64,
+                -730.125366f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, -0.02f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Juliet::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients706() {
+    fn test_naif_id_712() {
+        assert_eq!(Portia::id(), 712i32)
+    }
+    #[test]
+    fn test_tri_axial_712() {
+        assert_eq!(Portia::polar_radius(), 54f64);
+        assert_eq!(Portia::mean_radius(), 54f64);
+        assert_eq!(Portia::subplanetary_radius(), 54f64);
+        assert_eq!(Portia::along_orbit_radius(), 54f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_712() {
         assert_eq!(
-            &[
-                -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Cordelia::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Portia::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_707() {
-        assert_eq!(Ophelia::id(), 707i32)
+    fn test_rotational_elements_right_ascension_coefficients_712() {
+        assert_eq!(
+            (
+                257.31f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Portia::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_tri_axial_707() {
-        assert_eq!(Ophelia::polar_radius(), 15f64);
-        assert_eq!(Ophelia::mean_radius(), 15f64);
-        assert_eq!(Ophelia::subplanetary_radius(), 15f64);
-        assert_eq!(Ophelia::along_orbit_radius(), 15f64);
+    fn test_rotational_elements_declination_coefficients_712() {
+        assert_eq!(
+            (
+                -15.18f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Portia::declination_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_707() {
+    fn test_rotational_elements_prime_meridian_coefficients_712() {
         assert_eq!(
-            [257.31f64, 0f64, 0f64],
-            Ophelia::RIGHT_ASCENSION_COEFFICIENTS
+            (
+                25.03f64,
+                -701.486587f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.02f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Portia::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_707() {
-        assert_eq!([-15.18f64, 0f64, 0f64], Ophelia::DECLINATION_COEFFICIENTS)
+    fn test_naif_id_713() {
+        assert_eq!(Rosalind::id(), 713i32)
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_707() {
+    fn test_tri_axial_713() {
+        assert_eq!(Rosalind::polar_radius(), 27f64);
+        assert_eq!(Rosalind::mean_radius(), 27f64);
+        assert_eq!(Rosalind::subplanetary_radius(), 27f64);
+        assert_eq!(Rosalind::along_orbit_radius(), 27f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_713() {
         assert_eq!(
-            [130.35f64, -956.406815f64, 0f64],
-            Ophelia::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Rosalind::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients707() {
+    fn test_rotational_elements_right_ascension_coefficients_713() {
         assert_eq!(
-            &[
-                0f64, -0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Ophelia::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                257.31f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.29f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Rosalind::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients707() {
+    fn test_rotational_elements_declination_coefficients_713() {
         assert_eq!(
-            &[
-                0f64, 0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Ophelia::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                -15.18f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.28f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Rosalind::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients707() {
+    fn test_rotational_elements_prime_meridian_coefficients_713() {
         assert_eq!(
-            &[
-                0f64, -0.03f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Ophelia::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                314.9f64,
+                -644.631126f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.08f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Rosalind::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_708() {
-        assert_eq!(Bianca::id(), 708i32)
+    fn test_naif_id_714() {
+        assert_eq!(Belinda::id(), 714i32)
     }
     #[test]
-    fn test_tri_axial_708() {
-        assert_eq!(Bianca::polar_radius(), 21f64);
-        assert_eq!(Bianca::mean_radius(), 21f64);
-        assert_eq!(Bianca::subplanetary_radius(), 21f64);
-        assert_eq!(Bianca::along_orbit_radius(), 21f64);
+    fn test_tri_axial_714() {
+        assert_eq!(Belinda::polar_radius(), 33f64);
+        assert_eq!(Belinda::mean_radius(), 33f64);
+        assert_eq!(Belinda::subplanetary_radius(), 33f64);
+        assert_eq!(Belinda::along_orbit_radius(), 33f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_708() {
+    fn test_rotational_elements_nutation_precession_coefficients_714() {
         assert_eq!(
-            [257.31f64, 0f64, 0f64],
-            Bianca::RIGHT_ASCENSION_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Belinda::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_708() {
-        assert_eq!([-15.18f64, 0f64, 0f64], Bianca::DECLINATION_COEFFICIENTS)
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_708() {
+    fn test_rotational_elements_right_ascension_coefficients_714() {
         assert_eq!(
-            [105.46f64, -828.391476f64, 0f64],
-            Bianca::PRIME_MERIDIAN_COEFFICIENTS
+            (
+                257.31f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.03f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Belinda::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients708() {
+    fn test_rotational_elements_declination_coefficients_714() {
         assert_eq!(
-            &[
-                0f64, 0f64, -0.16f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Bianca::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                -15.18f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.03f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Belinda::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients708() {
+    fn test_rotational_elements_prime_meridian_coefficients_714() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0.16f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Bianca::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                297.46f64,
+                -577.362817f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.01f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Belinda::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients708() {
+    fn test_naif_id_715() {
+        assert_eq!(Puck::id(), 715i32)
+    }
+    #[test]
+    fn test_tri_axial_715() {
+        assert_eq!(Puck::polar_radius(), 77f64);
+        assert_eq!(Puck::mean_radius(), 77f64);
+        assert_eq!(Puck::subplanetary_radius(), 77f64);
+        assert_eq!(Puck::along_orbit_radius(), 77f64);
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_715() {
         assert_eq!(
-            &[
-                0f64, 0f64, -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Bianca::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Puck::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_709() {
-        assert_eq!(Cressida::id(), 709i32)
+    fn test_rotational_elements_right_ascension_coefficients_715() {
+        assert_eq!(
+            (
+                257.31f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.33f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Puck::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_tri_axial_709() {
-        assert_eq!(Cressida::polar_radius(), 31f64);
-        assert_eq!(Cressida::mean_radius(), 31f64);
-        assert_eq!(Cressida::subplanetary_radius(), 31f64);
-        assert_eq!(Cressida::along_orbit_radius(), 31f64);
+    fn test_rotational_elements_declination_coefficients_715() {
+        assert_eq!(
+            (
+                -15.18f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.31f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Puck::declination_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_709() {
+    fn test_rotational_elements_prime_meridian_coefficients_715() {
         assert_eq!(
-            [257.31f64, 0f64, 0f64],
-            Cressida::RIGHT_ASCENSION_COEFFICIENTS
+            (
+                91.24f64,
+                -472.545069f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.09f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Puck::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_709() {
-        assert_eq!([-15.18f64, 0f64, 0f64], Cressida::DECLINATION_COEFFICIENTS)
+    fn test_naif_id_716() {
+        assert_eq!(Caliban::id(), 716i32)
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_709() {
+    fn test_rotational_elements_nutation_precession_coefficients_716() {
         assert_eq!(
-            [59.16f64, -776.581632f64, 0f64],
-            Cressida::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Caliban::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients709() {
+    fn test_rotational_elements_right_ascension_coefficients_716() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Cressida::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Caliban::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients709() {
+    fn test_rotational_elements_declination_coefficients_716() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Cressida::NUT_PREC_DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Caliban::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients709() {
+    fn test_rotational_elements_prime_meridian_coefficients_716() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, -0.01f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Cressida::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Caliban::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_710() {
-        assert_eq!(Desdemona::id(), 710i32)
-    }
-    #[test]
-    fn test_tri_axial_710() {
-        assert_eq!(Desdemona::polar_radius(), 27f64);
-        assert_eq!(Desdemona::mean_radius(), 27f64);
-        assert_eq!(Desdemona::subplanetary_radius(), 27f64);
-        assert_eq!(Desdemona::along_orbit_radius(), 27f64);
+    fn test_naif_id_717() {
+        assert_eq!(Sycorax::id(), 717i32)
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_710() {
+    fn test_rotational_elements_nutation_precession_coefficients_717() {
         assert_eq!(
-            [257.31f64, 0f64, 0f64],
-            Desdemona::RIGHT_ASCENSION_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Sycorax::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_710() {
-        assert_eq!([-15.18f64, 0f64, 0f64], Desdemona::DECLINATION_COEFFICIENTS)
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_710() {
+    fn test_rotational_elements_right_ascension_coefficients_717() {
         assert_eq!(
-            [95.08f64, -760.053169f64, 0f64],
-            Desdemona::PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Sycorax::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients710() {
+    fn test_rotational_elements_declination_coefficients_717() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, -0.17f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Desdemona::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Sycorax::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients710() {
+    fn test_rotational_elements_prime_meridian_coefficients_717() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0.16f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Desdemona::NUT_PREC_DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Sycorax::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients710() {
+    fn test_naif_id_718() {
+        assert_eq!(Prospero::id(), 718i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_718() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Desdemona::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Prospero::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_711() {
-        assert_eq!(Juliet::id(), 711i32)
+    fn test_rotational_elements_right_ascension_coefficients_718() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Prospero::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_tri_axial_711() {
-        assert_eq!(Juliet::polar_radius(), 42f64);
-        assert_eq!(Juliet::mean_radius(), 42f64);
-        assert_eq!(Juliet::subplanetary_radius(), 42f64);
-        assert_eq!(Juliet::along_orbit_radius(), 42f64);
+    fn test_rotational_elements_declination_coefficients_718() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Prospero::declination_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_711() {
+    fn test_rotational_elements_prime_meridian_coefficients_718() {
         assert_eq!(
-            [257.31f64, 0f64, 0f64],
-            Juliet::RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Prospero::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_711() {
-        assert_eq!([-15.18f64, 0f64, 0f64], Juliet::DECLINATION_COEFFICIENTS)
+    fn test_naif_id_719() {
+        assert_eq!(Setebos::id(), 719i32)
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_711() {
+    fn test_rotational_elements_nutation_precession_coefficients_719() {
         assert_eq!(
-            [302.56f64, -730.125366f64, 0f64],
-            Juliet::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Setebos::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients711() {
+    fn test_rotational_elements_right_ascension_coefficients_719() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, -0.06f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Juliet::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Setebos::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients711() {
+    fn test_rotational_elements_declination_coefficients_719() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0.06f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Juliet::NUT_PREC_DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Setebos::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients711() {
+    fn test_rotational_elements_prime_meridian_coefficients_719() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, -0.02f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Juliet::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Setebos::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_712() {
-        assert_eq!(Portia::id(), 712i32)
-    }
-    #[test]
-    fn test_tri_axial_712() {
-        assert_eq!(Portia::polar_radius(), 54f64);
-        assert_eq!(Portia::mean_radius(), 54f64);
-        assert_eq!(Portia::subplanetary_radius(), 54f64);
-        assert_eq!(Portia::along_orbit_radius(), 54f64);
+    fn test_naif_id_720() {
+        assert_eq!(Stephano::id(), 720i32)
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_712() {
+    fn test_rotational_elements_nutation_precession_coefficients_720() {
         assert_eq!(
-            [257.31f64, 0f64, 0f64],
-            Portia::RIGHT_ASCENSION_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Stephano::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_712() {
-        assert_eq!([-15.18f64, 0f64, 0f64], Portia::DECLINATION_COEFFICIENTS)
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_712() {
+    fn test_rotational_elements_right_ascension_coefficients_720() {
         assert_eq!(
-            [25.03f64, -701.486587f64, 0f64],
-            Portia::PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Stephano::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients712() {
+    fn test_rotational_elements_declination_coefficients_720() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Portia::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Stephano::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients712() {
+    fn test_rotational_elements_prime_meridian_coefficients_720() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Portia::NUT_PREC_DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Stephano::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients712() {
+    fn test_naif_id_721() {
+        assert_eq!(Trinculo::id(), 721i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_721() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.02f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Portia::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Trinculo::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_713() {
-        assert_eq!(Rosalind::id(), 713i32)
+    fn test_rotational_elements_right_ascension_coefficients_721() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Trinculo::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_tri_axial_713() {
-        assert_eq!(Rosalind::polar_radius(), 27f64);
-        assert_eq!(Rosalind::mean_radius(), 27f64);
-        assert_eq!(Rosalind::subplanetary_radius(), 27f64);
-        assert_eq!(Rosalind::along_orbit_radius(), 27f64);
+    fn test_rotational_elements_declination_coefficients_721() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Trinculo::declination_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_713() {
+    fn test_rotational_elements_prime_meridian_coefficients_721() {
         assert_eq!(
-            [257.31f64, 0f64, 0f64],
-            Rosalind::RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Trinculo::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_713() {
-        assert_eq!([-15.18f64, 0f64, 0f64], Rosalind::DECLINATION_COEFFICIENTS)
+    fn test_naif_id_722() {
+        assert_eq!(Francisco::id(), 722i32)
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_713() {
+    fn test_rotational_elements_nutation_precession_coefficients_722() {
         assert_eq!(
-            [314.9f64, -644.631126f64, 0f64],
-            Rosalind::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Francisco::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients713() {
+    fn test_rotational_elements_right_ascension_coefficients_722() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.29f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Rosalind::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Francisco::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients713() {
+    fn test_rotational_elements_declination_coefficients_722() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.28f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Rosalind::NUT_PREC_DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Francisco::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients713() {
+    fn test_rotational_elements_prime_meridian_coefficients_722() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.08f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Rosalind::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Francisco::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_714() {
-        assert_eq!(Belinda::id(), 714i32)
-    }
-    #[test]
-    fn test_tri_axial_714() {
-        assert_eq!(Belinda::polar_radius(), 33f64);
-        assert_eq!(Belinda::mean_radius(), 33f64);
-        assert_eq!(Belinda::subplanetary_radius(), 33f64);
-        assert_eq!(Belinda::along_orbit_radius(), 33f64);
+    fn test_naif_id_723() {
+        assert_eq!(Margaret::id(), 723i32)
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_714() {
+    fn test_rotational_elements_nutation_precession_coefficients_723() {
         assert_eq!(
-            [257.31f64, 0f64, 0f64],
-            Belinda::RIGHT_ASCENSION_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Margaret::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_714() {
-        assert_eq!([-15.18f64, 0f64, 0f64], Belinda::DECLINATION_COEFFICIENTS)
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_714() {
+    fn test_rotational_elements_right_ascension_coefficients_723() {
         assert_eq!(
-            [297.46f64, -577.362817f64, 0f64],
-            Belinda::PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Margaret::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients714() {
+    fn test_rotational_elements_declination_coefficients_723() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.03f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Belinda::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Margaret::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients714() {
+    fn test_rotational_elements_prime_meridian_coefficients_723() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.03f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Belinda::NUT_PREC_DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Margaret::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients714() {
+    fn test_naif_id_724() {
+        assert_eq!(Ferdinand::id(), 724i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_724() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.01f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Belinda::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Ferdinand::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_715() {
-        assert_eq!(Puck::id(), 715i32)
+    fn test_rotational_elements_right_ascension_coefficients_724() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Ferdinand::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_tri_axial_715() {
-        assert_eq!(Puck::polar_radius(), 77f64);
-        assert_eq!(Puck::mean_radius(), 77f64);
-        assert_eq!(Puck::subplanetary_radius(), 77f64);
-        assert_eq!(Puck::along_orbit_radius(), 77f64);
+    fn test_rotational_elements_declination_coefficients_724() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Ferdinand::declination_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_715() {
-        assert_eq!([257.31f64, 0f64, 0f64], Puck::RIGHT_ASCENSION_COEFFICIENTS)
+    fn test_rotational_elements_prime_meridian_coefficients_724() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Ferdinand::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_rotational_elements_declination_coefficients_715() {
-        assert_eq!([-15.18f64, 0f64, 0f64], Puck::DECLINATION_COEFFICIENTS)
+    fn test_naif_id_725() {
+        assert_eq!(Perdita::id(), 725i32)
     }
     #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_715() {
+    fn test_rotational_elements_nutation_precession_coefficients_725() {
         assert_eq!(
-            [91.24f64, -472.545069f64, 0f64],
-            Puck::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Perdita::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients715() {
+    fn test_rotational_elements_right_ascension_coefficients_725() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.33f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Puck::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Perdita::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients715() {
+    fn test_rotational_elements_declination_coefficients_725() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.31f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Puck::NUT_PREC_DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Perdita::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients715() {
+    fn test_rotational_elements_prime_meridian_coefficients_725() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.09f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Puck::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Perdita::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_716() {
-        assert_eq!(Caliban::id(), 716i32)
-    }
-    #[test]
-    fn test_naif_id_717() {
-        assert_eq!(Sycorax::id(), 717i32)
-    }
-    #[test]
-    fn test_naif_id_718() {
-        assert_eq!(Prospero::id(), 718i32)
+    fn test_naif_id_726() {
+        assert_eq!(Mab::id(), 726i32)
     }
     #[test]
-    fn test_naif_id_719() {
-        assert_eq!(Setebos::id(), 719i32)
+    fn test_rotational_elements_nutation_precession_coefficients_726() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Mab::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_720() {
-        assert_eq!(Stephano::id(), 720i32)
+    fn test_rotational_elements_right_ascension_coefficients_726() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Mab::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_721() {
-        assert_eq!(Trinculo::id(), 721i32)
+    fn test_rotational_elements_declination_coefficients_726() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Mab::declination_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_722() {
-        assert_eq!(Francisco::id(), 722i32)
+    fn test_rotational_elements_prime_meridian_coefficients_726() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Mab::prime_meridian_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_723() {
-        assert_eq!(Margaret::id(), 723i32)
+    fn test_naif_id_727() {
+        assert_eq!(Cupid::id(), 727i32)
     }
     #[test]
-    fn test_naif_id_724() {
-        assert_eq!(Ferdinand::id(), 724i32)
+    fn test_rotational_elements_nutation_precession_coefficients_727() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Cupid::nutation_precession_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_725() {
-        assert_eq!(Perdita::id(), 725i32)
+    fn test_rotational_elements_right_ascension_coefficients_727() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Cupid::right_ascension_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_726() {
-        assert_eq!(Mab::id(), 726i32)
+    fn test_rotational_elements_declination_coefficients_727() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Cupid::declination_coefficients()
+        )
     }
     #[test]
-    fn test_naif_id_727() {
-        assert_eq!(Cupid::id(), 727i32)
+    fn test_rotational_elements_prime_meridian_coefficients_727() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Cupid::prime_meridian_coefficients()
+        )
     }
     #[test]
     fn test_naif_id_801() {
@@ -5945,51 +10942,55 @@ mod tests {
         assert_eq!(Triton::along_orbit_radius(), 1352.6f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_801() {
-        assert_eq!(
-            [299.36f64, 0f64, 0f64],
-            Triton::RIGHT_ASCENSION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_declination_coefficients_801() {
-        assert_eq!([41.17f64, 0f64, 0f64], Triton::DECLINATION_COEFFICIENTS)
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_801() {
+    fn test_rotational_elements_nutation_precession_coefficients_801() {
         assert_eq!(
-            [296.53f64, -61.2572637f64, 0f64],
-            Triton::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Triton::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients801() {
+    fn test_rotational_elements_right_ascension_coefficients_801() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -32.35f64, 0f64, -6.28f64, -2.08f64,
-                -0.74f64, -0.28f64, -0.11f64, -0.07f64, -0.02f64, -0.01f64
-            ],
-            Triton::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                299.36f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -32.35f64, 0f64, -6.28f64, -2.08f64,
+                    -0.74f64, -0.28f64, -0.11f64, -0.07f64, -0.02f64, -0.01f64
+                ] as &[f64]
+            ),
+            Triton::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients801() {
+    fn test_rotational_elements_declination_coefficients_801() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 22.55f64, 0f64, 2.1f64, 0.55f64, 0.16f64,
-                0.05f64, 0.02f64, 0.01f64, 0f64, 0f64
-            ],
-            Triton::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                41.17f64,
+                0f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 22.55f64, 0f64, 2.1f64, 0.55f64,
+                    0.16f64, 0.05f64, 0.02f64, 0.01f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Triton::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients801() {
+    fn test_rotational_elements_prime_meridian_coefficients_801() {
         assert_eq!(
-            &[
-                0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 22.25f64, 0f64, 6.73f64, 2.05f64,
-                0.74f64, 0.28f64, 0.11f64, 0.05f64, 0.02f64, 0.01f64
-            ],
-            Triton::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                296.53f64,
+                -61.2572637f64,
+                0f64,
+                &[
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 22.25f64, 0f64, 6.73f64, 2.05f64,
+                    0.74f64, 0.28f64, 0.11f64, 0.05f64, 0.02f64, 0.01f64
+                ] as &[f64]
+            ),
+            Triton::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -6004,6 +11005,34 @@ mod tests {
         assert_eq!(Nereid::along_orbit_radius(), 170f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_802() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Nereid::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_802() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Nereid::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_802() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Nereid::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_802() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Nereid::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_803() {
         assert_eq!(Naiad::id(), 803i32)
     }
@@ -6019,48 +11048,55 @@ mod tests {
         assert_eq!(Naiad::along_orbit_radius(), 29f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_803() {
-        assert_eq!([299.36f64, 0f64, 0f64], Naiad::RIGHT_ASCENSION_COEFFICIENTS)
-    }
-    #[test]
-    fn test_rotational_elements_declination_coefficients_803() {
-        assert_eq!([43.36f64, 0f64, 0f64], Naiad::DECLINATION_COEFFICIENTS)
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_803() {
+    fn test_rotational_elements_nutation_precession_coefficients_803() {
         assert_eq!(
-            [254.06f64, 1222.8441209f64, 0f64],
-            Naiad::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Naiad::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients803() {
+    fn test_rotational_elements_right_ascension_coefficients_803() {
         assert_eq!(
-            &[
-                0.7f64, -6.49f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.25f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Naiad::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                299.36f64,
+                0f64,
+                0f64,
+                &[
+                    0.7f64, -6.49f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.25f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Naiad::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients803() {
+    fn test_rotational_elements_declination_coefficients_803() {
         assert_eq!(
-            &[
-                -0.51f64, -4.75f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.09f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Naiad::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                43.36f64,
+                0f64,
+                0f64,
+                &[
+                    -0.51f64, -4.75f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.09f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Naiad::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients803() {
+    fn test_rotational_elements_prime_meridian_coefficients_803() {
         assert_eq!(
-            &[
-                -0.48f64, 4.4f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.27f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Naiad::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                254.06f64,
+                1222.8441209f64,
+                0f64,
+                &[
+                    -0.48f64, 4.4f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.27f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Naiad::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -6079,51 +11115,55 @@ mod tests {
         assert_eq!(Thalassa::along_orbit_radius(), 40f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_804() {
-        assert_eq!(
-            [299.36f64, 0f64, 0f64],
-            Thalassa::RIGHT_ASCENSION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_declination_coefficients_804() {
-        assert_eq!([43.45f64, 0f64, 0f64], Thalassa::DECLINATION_COEFFICIENTS)
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_804() {
+    fn test_rotational_elements_nutation_precession_coefficients_804() {
         assert_eq!(
-            [102.06f64, 1155.7555612f64, 0f64],
-            Thalassa::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Thalassa::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients804() {
+    fn test_rotational_elements_right_ascension_coefficients_804() {
         assert_eq!(
-            &[
-                0.7f64, 0f64, -0.28f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64
-            ],
-            Thalassa::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                299.36f64,
+                0f64,
+                0f64,
+                &[
+                    0.7f64, 0f64, -0.28f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Thalassa::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients804() {
+    fn test_rotational_elements_declination_coefficients_804() {
         assert_eq!(
-            &[
-                -0.51f64, 0f64, -0.21f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Thalassa::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                43.45f64,
+                0f64,
+                0f64,
+                &[
+                    -0.51f64, 0f64, -0.21f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Thalassa::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients804() {
+    fn test_rotational_elements_prime_meridian_coefficients_804() {
         assert_eq!(
-            &[
-                -0.48f64, 0f64, 0.19f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Thalassa::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                102.06f64,
+                1155.7555612f64,
+                0f64,
+                &[
+                    -0.48f64, 0f64, 0.19f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Thalassa::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -6142,51 +11182,55 @@ mod tests {
         assert_eq!(Despina::along_orbit_radius(), 74f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_805() {
-        assert_eq!(
-            [299.36f64, 0f64, 0f64],
-            Despina::RIGHT_ASCENSION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_declination_coefficients_805() {
-        assert_eq!([43.45f64, 0f64, 0f64], Despina::DECLINATION_COEFFICIENTS)
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_805() {
+    fn test_rotational_elements_nutation_precession_coefficients_805() {
         assert_eq!(
-            [306.51f64, 1075.7341562f64, 0f64],
-            Despina::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Despina::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients805() {
+    fn test_rotational_elements_right_ascension_coefficients_805() {
         assert_eq!(
-            &[
-                0.7f64, 0f64, 0f64, -0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64
-            ],
-            Despina::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                299.36f64,
+                0f64,
+                0f64,
+                &[
+                    0.7f64, 0f64, 0f64, -0.09f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Despina::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients805() {
+    fn test_rotational_elements_declination_coefficients_805() {
         assert_eq!(
-            &[
-                -0.51f64, 0f64, 0f64, -0.07f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Despina::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                43.45f64,
+                0f64,
+                0f64,
+                &[
+                    -0.51f64, 0f64, 0f64, -0.07f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Despina::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients805() {
+    fn test_rotational_elements_prime_meridian_coefficients_805() {
         assert_eq!(
-            &[
-                -0.49f64, 0f64, 0f64, 0.06f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Despina::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                306.51f64,
+                1075.7341562f64,
+                0f64,
+                &[
+                    -0.49f64, 0f64, 0f64, 0.06f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Despina::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -6205,51 +11249,55 @@ mod tests {
         assert_eq!(Galatea::along_orbit_radius(), 79f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_806() {
-        assert_eq!(
-            [299.36f64, 0f64, 0f64],
-            Galatea::RIGHT_ASCENSION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_declination_coefficients_806() {
-        assert_eq!([43.43f64, 0f64, 0f64], Galatea::DECLINATION_COEFFICIENTS)
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_806() {
+    fn test_rotational_elements_nutation_precession_coefficients_806() {
         assert_eq!(
-            [258.09f64, 839.6597686f64, 0f64],
-            Galatea::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Galatea::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients806() {
+    fn test_rotational_elements_right_ascension_coefficients_806() {
         assert_eq!(
-            &[
-                0.7f64, 0f64, 0f64, 0f64, -0.07f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64
-            ],
-            Galatea::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                299.36f64,
+                0f64,
+                0f64,
+                &[
+                    0.7f64, 0f64, 0f64, 0f64, -0.07f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Galatea::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients806() {
+    fn test_rotational_elements_declination_coefficients_806() {
         assert_eq!(
-            &[
-                -0.51f64, 0f64, 0f64, 0f64, -0.05f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Galatea::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                43.43f64,
+                0f64,
+                0f64,
+                &[
+                    -0.51f64, 0f64, 0f64, 0f64, -0.05f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Galatea::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients806() {
+    fn test_rotational_elements_prime_meridian_coefficients_806() {
         assert_eq!(
-            &[
-                -0.48f64, 0f64, 0f64, 0f64, 0.05f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Galatea::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                258.09f64,
+                839.6597686f64,
+                0f64,
+                &[
+                    -0.48f64, 0f64, 0f64, 0f64, 0.05f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Galatea::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -6268,51 +11316,55 @@ mod tests {
         assert_eq!(Larissa::along_orbit_radius(), 96f64);
     }
     #[test]
-    fn test_rotational_elements_right_ascension_coefficients_807() {
-        assert_eq!(
-            [299.36f64, 0f64, 0f64],
-            Larissa::RIGHT_ASCENSION_COEFFICIENTS
-        )
-    }
-    #[test]
-    fn test_rotational_elements_declination_coefficients_807() {
-        assert_eq!([43.41f64, 0f64, 0f64], Larissa::DECLINATION_COEFFICIENTS)
-    }
-    #[test]
-    fn test_rotational_elements_prime_meridian_coefficients_807() {
+    fn test_rotational_elements_nutation_precession_coefficients_807() {
         assert_eq!(
-            [179.41f64, 649.053447f64, 0f64],
-            Larissa::PRIME_MERIDIAN_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Larissa::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients807() {
+    fn test_rotational_elements_right_ascension_coefficients_807() {
         assert_eq!(
-            &[
-                0.7f64, 0f64, 0f64, 0f64, 0f64, -0.27f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64
-            ],
-            Larissa::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (
+                299.36f64,
+                0f64,
+                0f64,
+                &[
+                    0.7f64, 0f64, 0f64, 0f64, 0f64, -0.27f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Larissa::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients807() {
+    fn test_rotational_elements_declination_coefficients_807() {
         assert_eq!(
-            &[
-                -0.51f64, 0f64, 0f64, 0f64, 0f64, -0.2f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Larissa::NUT_PREC_DECLINATION_COEFFICIENTS
+            (
+                43.41f64,
+                0f64,
+                0f64,
+                &[
+                    -0.51f64, 0f64, 0f64, 0f64, 0f64, -0.2f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Larissa::declination_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients807() {
+    fn test_rotational_elements_prime_meridian_coefficients_807() {
         assert_eq!(
-            &[
-                -0.48f64, 0f64, 0f64, 0f64, 0f64, 0.19f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Larissa::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (
+                179.41f64,
+                649.053447f64,
+                0f64,
+                &[
+                    -0.48f64, 0f64, 0f64, 0f64, 0f64, 0.19f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Larissa::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -6331,74 +11383,218 @@ mod tests {
         assert_eq!(Proteus::along_orbit_radius(), 208f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_808() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Proteus::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_808() {
         assert_eq!(
-            [299.27f64, 0f64, 0f64],
-            Proteus::RIGHT_ASCENSION_COEFFICIENTS
+            (
+                299.27f64,
+                0f64,
+                0f64,
+                &[
+                    0.7f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.05f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Proteus::right_ascension_coefficients()
         )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_808() {
-        assert_eq!([42.91f64, 0f64, 0f64], Proteus::DECLINATION_COEFFICIENTS)
+        assert_eq!(
+            (
+                42.91f64,
+                0f64,
+                0f64,
+                &[
+                    -0.51f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Proteus::declination_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_808() {
         assert_eq!(
-            [93.38f64, 320.7654228f64, 0f64],
-            Proteus::PRIME_MERIDIAN_COEFFICIENTS
+            (
+                93.38f64,
+                320.7654228f64,
+                0f64,
+                &[
+                    -0.48f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64,
+                    0f64, 0f64, 0f64, 0f64, 0f64
+                ] as &[f64]
+            ),
+            Proteus::prime_meridian_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_right_ascension_coefficients808() {
+    fn test_naif_id_809() {
+        assert_eq!(Halimede::id(), 809i32)
+    }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_809() {
         assert_eq!(
-            &[
-                0.7f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.05f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64
-            ],
-            Proteus::NUT_PREC_RIGHT_ASCENSION_COEFFICIENTS
+            (&[] as &[f64], &[] as &[f64]),
+            Halimede::nutation_precession_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_declination_coefficients808() {
+    fn test_rotational_elements_right_ascension_coefficients_809() {
         assert_eq!(
-            &[
-                -0.51f64, 0f64, 0f64, 0f64, 0f64, 0f64, -0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Proteus::NUT_PREC_DECLINATION_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Halimede::right_ascension_coefficients()
         )
     }
     #[test]
-    fn test_trig_rotational_elements_nut_prec_prime_meridian_coefficients808() {
+    fn test_rotational_elements_declination_coefficients_809() {
         assert_eq!(
-            &[
-                -0.48f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0.04f64, 0f64, 0f64, 0f64, 0f64, 0f64,
-                0f64, 0f64, 0f64, 0f64, 0f64
-            ],
-            Proteus::NUT_PREC_PRIME_MERIDIAN_COEFFICIENTS
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Halimede::declination_coefficients()
         )
     }
     #[test]
-    fn test_naif_id_809() {
-        assert_eq!(Halimede::id(), 809i32)
+    fn test_rotational_elements_prime_meridian_coefficients_809() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Halimede::prime_meridian_coefficients()
+        )
     }
     #[test]
     fn test_naif_id_810() {
         assert_eq!(Psamathe::id(), 810i32)
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_810() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Psamathe::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_810() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Psamathe::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_810() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Psamathe::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_810() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Psamathe::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_811() {
         assert_eq!(Sao::id(), 811i32)
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_811() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Sao::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_811() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Sao::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_811() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Sao::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_811() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Sao::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_812() {
         assert_eq!(Laomedeia::id(), 812i32)
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_812() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Laomedeia::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_812() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Laomedeia::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_812() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Laomedeia::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_812() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Laomedeia::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_813() {
         assert_eq!(Neso::id(), 813i32)
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_813() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Neso::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_813() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Neso::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_813() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Neso::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_813() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Neso::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_901() {
         assert_eq!(Charon::id(), 901i32)
     }
@@ -6414,21 +11610,31 @@ mod tests {
         assert_eq!(Charon::along_orbit_radius(), 606f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_901() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Charon::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_901() {
         assert_eq!(
-            [132.993f64, 0f64, 0f64],
-            Charon::RIGHT_ASCENSION_COEFFICIENTS
+            (132.993f64, 0f64, 0f64, &[] as &[f64]),
+            Charon::right_ascension_coefficients()
         )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_901() {
-        assert_eq!([-6.163f64, 0f64, 0f64], Charon::DECLINATION_COEFFICIENTS)
+        assert_eq!(
+            (-6.163f64, 0f64, 0f64, &[] as &[f64]),
+            Charon::declination_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_901() {
         assert_eq!(
-            [122.695f64, 56.3625225f64, 0f64],
-            Charon::PRIME_MERIDIAN_COEFFICIENTS
+            (122.695f64, 56.3625225f64, 0f64, &[] as &[f64]),
+            Charon::prime_meridian_coefficients()
         )
     }
     #[test]
@@ -6440,6 +11646,34 @@ mod tests {
         assert_eq!(Nix::gravitational_parameter(), 0.00304817564816976f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_902() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Nix::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_902() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Nix::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_902() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Nix::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_902() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Nix::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_903() {
         assert_eq!(Hydra::id(), 903i32)
     }
@@ -6448,6 +11682,34 @@ mod tests {
         assert_eq!(Hydra::gravitational_parameter(), 0.003211039206155255f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_903() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Hydra::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_903() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Hydra::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_903() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Hydra::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_903() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Hydra::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_904() {
         assert_eq!(Kerberos::id(), 904i32)
     }
@@ -6456,6 +11718,34 @@ mod tests {
         assert_eq!(Kerberos::gravitational_parameter(), 0.001110040850536676f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_904() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Kerberos::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_904() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kerberos::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_904() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kerberos::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_904() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Kerberos::prime_meridian_coefficients()
+        )
+    }
+    #[test]
     fn test_naif_id_905() {
         assert_eq!(Styx::id(), 905i32)
     }
@@ -6463,4 +11753,32 @@ mod tests {
     fn test_point_mass_905() {
         assert_eq!(Styx::gravitational_parameter(), 0f64);
     }
+    #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_905() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Styx::nutation_precession_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_right_ascension_coefficients_905() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Styx::right_ascension_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_declination_coefficients_905() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Styx::declination_coefficients()
+        )
+    }
+    #[test]
+    fn test_rotational_elements_prime_meridian_coefficients_905() {
+        assert_eq!(
+            (0f64, 0f64, 0f64, &[] as &[f64]),
+            Styx::prime_meridian_coefficients()
+        )
+    }
 }
diff --git a/crates/lox_core/src/bodies/sun.rs b/crates/lox_core/src/bodies/sun.rs
index 1be49043..49fb6342 100644
--- a/crates/lox_core/src/bodies/sun.rs
+++ b/crates/lox_core/src/bodies/sun.rs
@@ -9,7 +9,8 @@
 // Auto-generated by `lox_gen`. Do not edit!
 
 use super::{
-    BodyRotationalElements, Ellipsoid, NaifId, PointMass, PolynomialCoefficient, Spheroid,
+    Ellipsoid, NaifId, NutationPrecessionCoefficients, PointMass, PolynomialCoefficients,
+    RotationalElements, Spheroid,
 };
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct Sun;
@@ -37,10 +38,19 @@ impl Spheroid for Sun {
     }
 }
 #[allow(clippy::approx_constant)]
-impl BodyRotationalElements for Sun {
-    const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = [286.13f64, 0f64, 0f64];
-    const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = [63.87f64, 0f64, 0f64];
-    const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = [84.176f64, 14.1844f64, 0f64];
+impl RotationalElements for Sun {
+    fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+        (&[] as &[f64], &[] as &[f64])
+    }
+    fn right_ascension_coefficients() -> PolynomialCoefficients {
+        (286.13f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn declination_coefficients() -> PolynomialCoefficients {
+        (63.87f64, 0f64, 0f64, &[] as &[f64])
+    }
+    fn prime_meridian_coefficients() -> PolynomialCoefficients {
+        (84.176f64, 14.1844f64, 0f64, &[] as &[f64])
+    }
 }
 #[cfg(test)]
 #[allow(clippy::approx_constant)]
@@ -61,18 +71,31 @@ mod tests {
         assert_eq!(Sun::equatorial_radius(), 695700f64);
     }
     #[test]
+    fn test_rotational_elements_nutation_precession_coefficients_10() {
+        assert_eq!(
+            (&[] as &[f64], &[] as &[f64]),
+            Sun::nutation_precession_coefficients()
+        )
+    }
+    #[test]
     fn test_rotational_elements_right_ascension_coefficients_10() {
-        assert_eq!([286.13f64, 0f64, 0f64], Sun::RIGHT_ASCENSION_COEFFICIENTS)
+        assert_eq!(
+            (286.13f64, 0f64, 0f64, &[] as &[f64]),
+            Sun::right_ascension_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_declination_coefficients_10() {
-        assert_eq!([63.87f64, 0f64, 0f64], Sun::DECLINATION_COEFFICIENTS)
+        assert_eq!(
+            (63.87f64, 0f64, 0f64, &[] as &[f64]),
+            Sun::declination_coefficients()
+        )
     }
     #[test]
     fn test_rotational_elements_prime_meridian_coefficients_10() {
         assert_eq!(
-            [84.176f64, 14.1844f64, 0f64],
-            Sun::PRIME_MERIDIAN_COEFFICIENTS
+            (84.176f64, 14.1844f64, 0f64, &[] as &[f64]),
+            Sun::prime_meridian_coefficients()
         )
     }
 }
diff --git a/tools/lox_gen/src/main.rs b/tools/lox_gen/src/main.rs
index a0d12649..8b4f787c 100644
--- a/tools/lox_gen/src/main.rs
+++ b/tools/lox_gen/src/main.rs
@@ -15,9 +15,9 @@ use proc_macro2::{Ident, TokenStream};
 use quote::{format_ident, quote};
 
 use lox_io::spice::Kernel;
-use naif_ids::{BARYCENTERS, Body, MINOR_BODIES, PLANETS, SATELLITES, SUN};
+use naif_ids::{Body, BARYCENTERS, MINOR_BODIES, PLANETS, SATELLITES, SUN};
 
-use crate::rotational_elements::RotationalElements;
+use crate::rotational_elements::{CoefficientKernel, RotationalElements};
 
 mod naif_ids;
 mod rotational_elements;
@@ -314,21 +314,17 @@ fn rotational_elements(
     id: &i32,
     data: &Data,
 ) {
-    let elements =
-        if let Some(elements) = RotationalElements::parse(*id as u32, ident, &data.pck) {
-            elements
-        } else {
-            return;
-        };
+    let elements = match RotationalElements::parse(*id as u32, ident, CoefficientKernel(&data.pck))
+    {
+        Ok(elements) => elements,
+        Err(err) => panic!("failed to parse rotational elements for {}: {}", ident, err),
+    };
 
     imports.extend([
-        format_ident!("BodyRotationalElements"),
-        format_ident!("PolynomialCoefficient"),
+        format_ident!("RotationalElements"),
+        format_ident!("PolynomialCoefficients"),
+        format_ident!("NutationPrecessionCoefficients"),
     ]);
-    if elements.has_trig_elements() {
-        imports.insert(format_ident!("BodyTrigRotationalElements"));
-    }
-
     code.extend(elements.code_tokens());
     tests.extend(elements.test_tokens());
 }
diff --git a/tools/lox_gen/src/naif_ids.rs b/tools/lox_gen/src/naif_ids.rs
index 26cf4826..91ef5548 100644
--- a/tools/lox_gen/src/naif_ids.rs
+++ b/tools/lox_gen/src/naif_ids.rs
@@ -35,6 +35,10 @@ pub const PLANETS: [Body; 9] = [
     (999, "Pluto"),
 ];
 
+pub fn is_planet(id: i32) -> bool {
+    PLANETS.iter().any(|(i, _)| *i == id)
+}
+
 pub const SATELLITES: [Body; 152] = [
     (301, "Moon"),
     (401, "Phobos"),
diff --git a/tools/lox_gen/src/rotational_elements.rs b/tools/lox_gen/src/rotational_elements.rs
index ad2322f7..f9b091ef 100644
--- a/tools/lox_gen/src/rotational_elements.rs
+++ b/tools/lox_gen/src/rotational_elements.rs
@@ -6,30 +6,34 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-use lox_core::bodies::{NutationPrecessionCoefficients, PolynomialCoefficients, N_COEFFICIENTS};
 use proc_macro2::{Ident, TokenStream};
 use quote::{format_ident, quote, ToTokens};
 use thiserror::Error;
 
 use lox_io::spice::Kernel;
 
+use crate::naif_ids::is_planet;
+
 /// Converts a set of PolynomialCoefficients into a TokenStream.
-struct TokenizeablePolynomialCoefficients(PolynomialCoefficients);
+pub struct TokenizeablePolynomialCoefficients(f64, f64, f64, Vec<f64>);
 
 impl ToTokens for TokenizeablePolynomialCoefficients {
     fn to_tokens(&self, tokens: &mut TokenStream) {
-        let PolynomialCoefficients(a, b, c, d) = self.0;
-        tokens.extend(quote! { PolynomialCoefficients(#a, #b, #c, #d) });
+        let Self(a, b, c, d) = self;
+        // The explicit type annotation is required to support the case of an empty slice.
+        tokens.extend(quote! { (#a, #b, #c, &[#(#d),*] as &[f64]) });
     }
 }
 
 /// Converts a set of NutationPrecessionCoefficients into a TokenStream.
-struct TokenizeableNutPrecCoefficients(NutationPrecessionCoefficients);
+#[derive(Default)]
+pub struct TokenizeableNutPrecCoefficients((Vec<f64>, Vec<f64>));
 
 impl ToTokens for TokenizeableNutPrecCoefficients {
     fn to_tokens(&self, tokens: &mut TokenStream) {
-        let NutationPrecessionCoefficients(a, b) = self.0;
-        tokens.extend(quote! { NutationPrecessionCoefficients([#(#a),*], [#(#b),*]) });
+        let (a, b) = &self.0;
+        // The explicit type annotations are required to support the case of an empty slice.
+        tokens.extend(quote! { (&[#(#a),*] as &[f64], &[#(#b),*] as &[f64]) });
     }
 }
 
@@ -37,109 +41,165 @@ impl ToTokens for TokenizeableNutPrecCoefficients {
 ///
 /// May be parsed directly from PCK data and knows how to represent its code and test components as
 /// streams of tokens.
-pub(crate) struct RotationalElements<'a, 'b> {
+///
+/// Wherever data is not available for a given body, the corresponding fields will be represented
+/// as the default value for the type.
+pub(crate) struct RotationalElements<'a> {
     id: u32,
     ident: &'a Ident,
-    right_ascension: [f64; 3],
-    declination: [f64; 3],
-    prime_meridian: [f64; 3],
-    // Not all bodies have trigonometric rotational elements, so we encapsulate these fields in
-    // a separate, optional struct.
-    trig_elements: Option<TrigonometricElements<'b>>,
-}
+    right_ascension: TokenizeablePolynomialCoefficients,
+    declination: TokenizeablePolynomialCoefficients,
+    prime_meridian: TokenizeablePolynomialCoefficients,
 
-impl<'a, 'b> RotationalElements<'a, 'b> {
-    pub(crate) fn parse(id: u32, ident: &'a Ident, kernel: &'b Kernel) -> Option<Self> {
-        let right_ascension_key = format!("BODY{}_POLE_RA", id);
-        let declination_key = format!("BODY{}_POLE_DEC", id);
-        let prime_meridian_key = format!("BODY{}_PM", id);
+    /// barycenter_nut_prec_coefficients will be the type default for all bodies except the prime
+    /// bodies of their respective systems.
+    barycenter_nut_prec_coefficients: TokenizeableNutPrecCoefficients,
+}
 
-        Some(Self {
+impl<'a> RotationalElements<'a> {
+    pub(crate) fn parse(
+        id: u32,
+        ident: &'a Ident,
+        kernel: impl GetPolynomialCoefficients,
+    ) -> Result<Self, Box<CoefficientsError>> {
+        Ok(Self {
             id,
             ident,
-            right_ascension: get_polynomial_coefficients_or_default(&right_ascension_key, kernel)?,
-            declination: get_polynomial_coefficients_or_default(&declination_key, kernel)?,
-            prime_meridian: get_polynomial_coefficients_or_default(&prime_meridian_key, kernel)?,
-            trig_elements: TrigonometricElements::parse(id, kernel),
+            right_ascension: kernel.get_right_ascension_coefficients_or_default(id)?,
+            declination: kernel.get_declination_coefficients_or_default(id)?,
+            prime_meridian: kernel.get_prime_meridian_coefficients_or_default(id)?,
+            barycenter_nut_prec_coefficients: kernel
+                .get_barycenter_nut_prec_coefficients_or_default(id)?,
         })
     }
 
     /// Returns the TokenStream corresponding to the [lox_core::bodies::BodyRotationalElements] impl.
     pub(crate) fn code_tokens(&self) -> TokenStream {
         let ident = self.ident;
-        let right_ascension = array_tokens_for(&self.right_ascension);
-        let declination = array_tokens_for(&self.declination);
-        let prime_meridian = array_tokens_for(&self.prime_meridian);
+        let barycenter_nut_prec = &self.barycenter_nut_prec_coefficients;
+        let right_ascension = &self.right_ascension;
+        let declination = &self.declination;
+        let prime_meridian = &self.prime_meridian;
 
-        let mut tokens = quote! {
+        quote! {
             #[allow(clippy::approx_constant)]
-            impl BodyRotationalElements for #ident {
-                const RIGHT_ASCENSION_COEFFICIENTS: [PolynomialCoefficient; 3] = #right_ascension;
-                const DECLINATION_COEFFICIENTS: [PolynomialCoefficient; 3] = #declination;
-                const PRIME_MERIDIAN_COEFFICIENTS: [PolynomialCoefficient; 3] = #prime_meridian;
-            }
-        };
+            impl RotationalElements for #ident {
+                fn nutation_precession_coefficients() -> NutationPrecessionCoefficients {
+                    #barycenter_nut_prec
+                }
 
-        if let Some(trig_elements) = &self.trig_elements {
-            tokens.extend(trig_elements.code_tokens(self.ident));
-        }
+                fn right_ascension_coefficients() -> PolynomialCoefficients {
+                    #right_ascension
+                }
+
+                fn declination_coefficients() -> PolynomialCoefficients {
+                    #declination
+                }
 
-        tokens
+                fn prime_meridian_coefficients() -> PolynomialCoefficients {
+                    #prime_meridian
+                }
+            }
+        }
     }
 
     /// Returns the TokenStream testing the [lox_core::bodies::BodyRotationalElements] impl.
     pub(crate) fn test_tokens(&self) -> TokenStream {
         let ident = self.ident;
-        let right_ascension = array_tokens_for(&self.right_ascension);
-        let declination = array_tokens_for(&self.declination);
-        let prime_meridian = array_tokens_for(&self.prime_meridian);
+        let barycenter_nut_prec = &self.barycenter_nut_prec_coefficients;
+        let right_ascension = &self.right_ascension;
+        let declination = &self.declination;
+        let prime_meridian = &self.prime_meridian;
+
+        let barycenter_nut_prec_test_name = format_ident!(
+            "test_rotational_elements_nutation_precession_coefficients_{}",
+            self.id
+        );
 
         let right_ascension_test_name = format_ident!(
             "test_rotational_elements_right_ascension_coefficients_{}",
             self.id
         );
+
         let declination_test_name = format_ident!(
             "test_rotational_elements_declination_coefficients_{}",
             self.id
         );
+
         let prime_meridian_test_name = format_ident!(
             "test_rotational_elements_prime_meridian_coefficients_{}",
             self.id
         );
 
-        let mut tokens = quote! {
+        quote! {
+            #[test]
+            fn #barycenter_nut_prec_test_name() {
+                assert_eq!(#barycenter_nut_prec, #ident::nutation_precession_coefficients())
+            }
+
             #[test]
             fn #right_ascension_test_name() {
-                assert_eq!(#right_ascension, #ident::RIGHT_ASCENSION_COEFFICIENTS)
+                assert_eq!(#right_ascension, #ident::right_ascension_coefficients())
             }
 
             #[test]
             fn #declination_test_name() {
-                assert_eq!(#declination, #ident::DECLINATION_COEFFICIENTS)
+                assert_eq!(#declination, #ident::declination_coefficients())
             }
 
             #[test]
             fn #prime_meridian_test_name() {
-                assert_eq!(#prime_meridian, #ident::PRIME_MERIDIAN_COEFFICIENTS)
+                assert_eq!(#prime_meridian, #ident::prime_meridian_coefficients())
             }
-        };
-
-        if let Some(trig_elements) = &self.trig_elements {
-            tokens.extend(trig_elements.test_tokens(self.id, self.ident));
         }
-
-        tokens
     }
+}
 
-    pub(crate) fn has_trig_elements(&self) -> bool {
-        self.trig_elements.is_some()
-    }
+/// Indicates that a value retrieved from the kernel did not conform to the domain model.
+#[derive(Debug, Error)]
+pub enum CoefficientsError {
+    #[error("Kernel coefficients with key {key} had size {actual}, expected at least {actual}")]
+    TooFew {
+        key: String,
+        min: usize,
+        actual: usize,
+    },
+    #[error("Kernel coefficients with key {key} had size {actual}, expected at most {actual}")]
+    TooMany {
+        key: String,
+        max: usize,
+        actual: usize,
+    },
+    #[error("Barycenter nutation precession coefficients with key {key} had an odd number of terms, but an even number is required")]
+    OddNumber { key: String },
+}
 
-    fn barycenter_id(&self) -> u32 {
-        self.id / 100
-    }
+/// GetPolynomialCoefficients supports translation between a raw PCK kernel and RotationalElements.
+pub trait GetPolynomialCoefficients {
+    fn get_right_ascension_coefficients_or_default(
+        &self,
+        id: u32,
+    ) -> Result<TokenizeablePolynomialCoefficients, Box<CoefficientsError>>;
+
+    fn get_declination_coefficients_or_default(
+        &self,
+        id: u32,
+    ) -> Result<TokenizeablePolynomialCoefficients, Box<CoefficientsError>>;
+
+    fn get_prime_meridian_coefficients_or_default(
+        &self,
+        id: u32,
+    ) -> Result<TokenizeablePolynomialCoefficients, Box<CoefficientsError>>;
+
+    fn get_barycenter_nut_prec_coefficients_or_default(
+        &self,
+        barycenter_id: u32,
+    ) -> Result<TokenizeableNutPrecCoefficients, Box<CoefficientsError>>;
 }
 
+/// Concrete translator from a raw PCK kernel to RotationalElements.
+pub struct CoefficientKernel<'a>(pub &'a Kernel);
+
 /// The type of coefficient to be retrieved from the kernel.
 enum PolynomialCoefficientType {
     RightAscension,
@@ -167,60 +227,97 @@ impl PolynomialCoefficientType {
     }
 }
 
-/// Indicates that a value retrieved from the kernel did not conform to the domain model.
-#[derive(Debug, Error)]
-pub(crate) enum ParsingError {
-    #[error("Kernel coefficients with key {key} had size {actual}, expected at least {actual}")]
-    TooFewTerms {
-        key: String,
-        min: usize,
-        actual: usize,
-    },
-    #[error("Kernel coefficients with key {key} had size {actual}, expected at most {actual}")]
-    TooManyTerms {
-        key: String,
-        max: usize,
-        actual: usize,
-    },
-    #[error("Barycenter nutation precession coefficients with key {key} had an odd number of terms, but an even number is required")]
-    OddTerms { key: String },
-}
+impl GetPolynomialCoefficients for CoefficientKernel<'_> {
+    fn get_right_ascension_coefficients_or_default(
+        &self,
+        id: u32,
+    ) -> Result<TokenizeablePolynomialCoefficients, Box<CoefficientsError>> {
+        self.get_polynomial_coefficients_or_default(id, PolynomialCoefficientType::RightAscension)
+    }
+
+    fn get_declination_coefficients_or_default(
+        &self,
+        id: u32,
+    ) -> Result<TokenizeablePolynomialCoefficients, Box<CoefficientsError>> {
+        self.get_polynomial_coefficients_or_default(id, PolynomialCoefficientType::Declination)
+    }
+
+    fn get_prime_meridian_coefficients_or_default(
+        &self,
+        id: u32,
+    ) -> Result<TokenizeablePolynomialCoefficients, Box<CoefficientsError>> {
+        self.get_polynomial_coefficients_or_default(id, PolynomialCoefficientType::PrimeMeridian)
+    }
+
+    fn get_barycenter_nut_prec_coefficients_or_default(
+        &self,
+        id: u32,
+    ) -> Result<TokenizeableNutPrecCoefficients, Box<CoefficientsError>> {
+        if !is_planet(id as i32) {
+            return Ok(TokenizeableNutPrecCoefficients::default());
+        }
 
-/// Translation layer between the Kernel and RotationalElements.
-struct CoefficientKernel<'a>(&'a Kernel);
+        let barycenter_id = id / 100;
+
+        let key = format!("BODY{}_NUT_PREC_ANGLES", barycenter_id);
+        match self.0.get_double_array(&key) {
+            None => Ok(TokenizeableNutPrecCoefficients::default()),
+            // The raw kernel data is an array of implicit pairs, so the number of coefficients must
+            // always be even.
+            Some(coefficients) if coefficients.len() % 2 == 1 => {
+                Err(Box::new(CoefficientsError::OddNumber {
+                    key: key.to_string(),
+                }))
+            }
+            // Split the implicit pairs into two index-matched arrays.
+            Some(coefficients) => {
+                let mut a: Vec<f64> = Vec::new();
+                let mut b: Vec<f64> = Vec::new();
+                for (i, coefficient) in coefficients.iter().enumerate() {
+                    if i % 2 == 0 {
+                        a.push(*coefficient);
+                    } else {
+                        b.push(*coefficient);
+                    }
+                }
+                Ok(TokenizeableNutPrecCoefficients((a, b)))
+            }
+        }
+    }
+}
 
 impl<'a> CoefficientKernel<'a> {
     fn get_polynomial_coefficients_or_default(
         &self,
         id: u32,
         pct: PolynomialCoefficientType,
-    ) -> Result<TokenizeablePolynomialCoefficients, Box<ParsingError>> {
+    ) -> Result<TokenizeablePolynomialCoefficients, Box<CoefficientsError>> {
         let (key, nut_prec_key) = pct.keys(id);
         let non_trig_coefficients = self.get_non_trig_coefficients_or_default(&key)?;
         let nut_prec_coefficients = self.get_nut_prec_coefficients_or_default(&nut_prec_key)?;
-        Ok(TokenizeablePolynomialCoefficients(PolynomialCoefficients(
+        Ok(TokenizeablePolynomialCoefficients(
             non_trig_coefficients[0],
             non_trig_coefficients[1],
             non_trig_coefficients[2],
             nut_prec_coefficients,
-        )))
+        ))
     }
 
     fn get_non_trig_coefficients_or_default(
         &self,
         key: &str,
-    ) -> Result<[f64; 3], Box<ParsingError>> {
+    ) -> Result<[f64; 3], Box<CoefficientsError>> {
         match self.0.get_double_array(key) {
             None => Ok([0.0; 3]),
             Some(polynomials) if polynomials.len() < 2 => {
-                Err(Box::new(ParsingError::TooFewTerms {
+                Err(Box::new(CoefficientsError::TooFew {
                     key: key.to_string(),
                     min: 2,
                     actual: polynomials.len(),
                 }))
             }
             Some(polynomials) if polynomials.len() > 3 => {
-                Err(Box::new(ParsingError::TooManyTerms {
+                Err(Box::new(CoefficientsError::TooMany {
                     key: key.to_string(),
                     max: 3,
                     actual: polynomials.len(),
@@ -228,7 +325,7 @@ impl<'a> CoefficientKernel<'a> {
             }
             Some(polynomials) => {
                 let mut polynomial_coefficients = [0.0; 3];
-                polynomial_coefficients.copy_from_slice(&polynomials);
+                polynomial_coefficients[..polynomials.len()].copy_from_slice(polynomials);
                 Ok(polynomial_coefficients)
             }
         }
@@ -237,57 +334,10 @@ impl<'a> CoefficientKernel<'a> {
     fn get_nut_prec_coefficients_or_default(
         &self,
         key: &str,
-    ) -> Result<[f64; N_COEFFICIENTS], Box<ParsingError>> {
+    ) -> Result<Vec<f64>, Box<CoefficientsError>> {
         match self.0.get_double_array(key) {
-            None => Ok([0.0; N_COEFFICIENTS]),
-            Some(coefficients) if coefficients.len() <= N_COEFFICIENTS => {
-                let mut nut_prec_coefficients = [0.0; N_COEFFICIENTS];
-                nut_prec_coefficients.copy_from_slice(&coefficients);
-                Some(nut_prec_coefficients)
-            }
-            Some(coefficients) => Err(Box::new(ParsingError::TooManyTerms {
-                key: key.to_string(),
-                max: N_COEFFICIENTS,
-                actual: coefficients.len(),
-            })),
-        }
-    }
-
-    fn get_barycenter_nut_prec_coefficients(
-        &self,
-        barycenter_id: u32,
-    ) -> Result<TokenizeableNutPrecCoefficients, Box<ParsingError>> {
-        let key = format!("BODY{}_NUT_PREC_ANGLES", barycenter_id);
-        match self.0.get_double_array(&key) {
-            None => Ok(TokenizeableNutPrecCoefficients(
-                NutationPrecessionCoefficients::default(),
-            )),
-            Some(coefficients) if coefficients.len() > N_COEFFICIENTS * 2 => {
-                Err(Box::new(ParsingError::TooManyTerms {
-                    key: key.to_string(),
-                    max: N_COEFFICIENTS * 2,
-                    actual: coefficients.len(),
-                }))
-            }
-            Some(coefficients) if coefficients.len() % 2 == 1 => {
-                Err(Box::new(ParsingError::OddTerms {
-                    key: key.to_string(),
-                }))
-            }
-            Some(coefficients) => {
-                let mut a = [0.0; N_COEFFICIENTS];
-                let mut b = [0.0; N_COEFFICIENTS];
-                coefficients.iter().enumerate().for_each(|(i, c)| {
-                    if i % 2 == 0 {
-                        a[i / 2] = *c;
-                    } else {
-                        b[i / 2] = *c;
-                    }
-                });
-                Ok(TokenizeableNutPrecCoefficients(
-                    NutationPrecessionCoefficients(a, b),
-                ))
-            }
+            None => Ok(vec![]),
+            Some(coefficients) => Ok(coefficients.to_vec()),
         }
     }
 }