/*
 * Copyright (c) 2024. Helge Eichhorn and the LOX contributors
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, you can obtain one at https://mozilla.org/MPL/2.0/.
 */

// Auto-generated by `lox-gen`. Do not edit!

use crate::{
    Body, Ellipsoid, MinorBody, NaifId, NutationPrecessionCoefficients, PointMass,
    PolynomialCoefficients, RotationalElements, TriAxial,
};
use std::fmt::{Display, Formatter};
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct Gaspra;
impl Body for Gaspra {
    fn id(&self) -> NaifId {
        NaifId(9511010i32)
    }
    fn name(&self) -> &'static str {
        "Gaspra"
    }
}
impl Display for Gaspra {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}
impl Ellipsoid for Gaspra {
    fn polar_radius(&self) -> f64 {
        4.4f64
    }
    fn mean_radius(&self) -> f64 {
        6.233333333333334f64
    }
}
impl TriAxial for Gaspra {
    fn subplanetary_radius(&self) -> f64 {
        9.1f64
    }
    fn along_orbit_radius(&self) -> f64 {
        5.2f64
    }
}
#[allow(clippy::approx_constant)]
impl RotationalElements for Gaspra {
    fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients {
        (&[] as &[f64], &[] as &[f64])
    }
    fn right_ascension_coefficients(&self) -> PolynomialCoefficients {
        (0.16528268016386302f64, 0f64, 0f64, &[] as &[f64])
    }
    fn declination_coefficients(&self) -> PolynomialCoefficients {
        (0.46600291028248597f64, 0f64, 0f64, &[] as &[f64])
    }
    fn prime_meridian_coefficients(&self) -> PolynomialCoefficients {
        (
            1.4603169851436555f64,
            21.41364504378302f64,
            0f64,
            &[] as &[f64],
        )
    }
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct Ida;
impl Body for Ida {
    fn id(&self) -> NaifId {
        NaifId(2431010i32)
    }
    fn name(&self) -> &'static str {
        "Ida"
    }
}
impl Display for Ida {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}
impl Ellipsoid for Ida {
    fn polar_radius(&self) -> f64 {
        7.6f64
    }
    fn mean_radius(&self) -> f64 {
        15.466666666666667f64
    }
}
impl TriAxial for Ida {
    fn subplanetary_radius(&self) -> f64 {
        26.8f64
    }
    fn along_orbit_radius(&self) -> f64 {
        12f64
    }
}
#[allow(clippy::approx_constant)]
impl RotationalElements for Ida {
    fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients {
        (&[] as &[f64], &[] as &[f64])
    }
    fn right_ascension_coefficients(&self) -> PolynomialCoefficients {
        (2.9454176456656302f64, 0f64, 0f64, &[] as &[f64])
    }
    fn declination_coefficients(&self) -> PolynomialCoefficients {
        (-1.5205308443374599f64, 0f64, 0f64, &[] as &[f64])
    }
    fn prime_meridian_coefficients(&self) -> PolynomialCoefficients {
        (
            4.78307481509046f64,
            32.54389804704987f64,
            0f64,
            &[] as &[f64],
        )
    }
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct Dactyl;
impl Body for Dactyl {
    fn id(&self) -> NaifId {
        NaifId(2431011i32)
    }
    fn name(&self) -> &'static str {
        "Dactyl"
    }
}
impl Display for Dactyl {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}
#[allow(clippy::approx_constant)]
impl RotationalElements for Dactyl {
    fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients {
        (&[] as &[f64], &[] as &[f64])
    }
    fn right_ascension_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
    fn declination_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
    fn prime_meridian_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct Ceres;
impl MinorBody for Ceres {}
impl Body for Ceres {
    fn id(&self) -> NaifId {
        NaifId(2000001i32)
    }
    fn name(&self) -> &'static str {
        "Ceres"
    }
}
impl Display for Ceres {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}
impl Ellipsoid for Ceres {
    fn polar_radius(&self) -> f64 {
        446f64
    }
    fn mean_radius(&self) -> f64 {
        473.5333333333333f64
    }
}
impl TriAxial for Ceres {
    fn subplanetary_radius(&self) -> f64 {
        487.3f64
    }
    fn along_orbit_radius(&self) -> f64 {
        487.3f64
    }
}
impl PointMass for Ceres {
    fn gravitational_parameter(&self) -> f64 {
        62.62888864440993f64
    }
}
#[allow(clippy::approx_constant)]
impl RotationalElements for Ceres {
    fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients {
        (&[] as &[f64], &[] as &[f64])
    }
    fn right_ascension_coefficients(&self) -> PolynomialCoefficients {
        (5.0862035995768355f64, 0f64, 0f64, &[] as &[f64])
    }
    fn declination_coefficients(&self) -> PolynomialCoefficients {
        (1.165251621801494f64, 0f64, 0f64, &[] as &[f64])
    }
    fn prime_meridian_coefficients(&self) -> PolynomialCoefficients {
        (
            2.9784043685283237f64,
            16.618208323400072f64,
            0f64,
            &[] as &[f64],
        )
    }
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct Pallas;
impl Body for Pallas {
    fn id(&self) -> NaifId {
        NaifId(2000002i32)
    }
    fn name(&self) -> &'static str {
        "Pallas"
    }
}
impl Display for Pallas {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}
impl PointMass for Pallas {
    fn gravitational_parameter(&self) -> f64 {
        13.665878145967422f64
    }
}
#[allow(clippy::approx_constant)]
impl RotationalElements for Pallas {
    fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients {
        (&[] as &[f64], &[] as &[f64])
    }
    fn right_ascension_coefficients(&self) -> PolynomialCoefficients {
        (0.5759586531581288f64, 0f64, 0f64, &[] as &[f64])
    }
    fn declination_coefficients(&self) -> PolynomialCoefficients {
        (-0.05235987755982989f64, 0f64, 0f64, &[] as &[f64])
    }
    fn prime_meridian_coefficients(&self) -> PolynomialCoefficients {
        (
            0.6632251157578453f64,
            19.299913700406368f64,
            0f64,
            &[] as &[f64],
        )
    }
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct Vesta;
impl MinorBody for Vesta {}
impl Body for Vesta {
    fn id(&self) -> NaifId {
        NaifId(2000004i32)
    }
    fn name(&self) -> &'static str {
        "Vesta"
    }
}
impl Display for Vesta {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}
impl Ellipsoid for Vesta {
    fn polar_radius(&self) -> f64 {
        229f64
    }
    fn mean_radius(&self) -> f64 {
        266f64
    }
}
impl TriAxial for Vesta {
    fn subplanetary_radius(&self) -> f64 {
        289f64
    }
    fn along_orbit_radius(&self) -> f64 {
        280f64
    }
}
impl PointMass for Vesta {
    fn gravitational_parameter(&self) -> f64 {
        17.288232879171513f64
    }
}
#[allow(clippy::approx_constant)]
impl RotationalElements for Vesta {
    fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients {
        (&[] as &[f64], &[] as &[f64])
    }
    fn right_ascension_coefficients(&self) -> PolynomialCoefficients {
        (5.393608440730596f64, 0f64, 0f64, &[] as &[f64])
    }
    fn declination_coefficients(&self) -> PolynomialCoefficients {
        (0.7371398095798051f64, 0f64, 0f64, &[] as &[f64])
    }
    fn prime_meridian_coefficients(&self) -> PolynomialCoefficients {
        (
            4.980995152266617f64,
            28.22778495282912f64,
            0f64,
            &[] as &[f64],
        )
    }
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct Psyche;
impl MinorBody for Psyche {}
impl Body for Psyche {
    fn id(&self) -> NaifId {
        NaifId(2000016i32)
    }
    fn name(&self) -> &'static str {
        "Psyche"
    }
}
impl Display for Psyche {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}
impl Ellipsoid for Psyche {
    fn polar_radius(&self) -> f64 {
        94.5f64
    }
    fn mean_radius(&self) -> f64 {
        116.66666666666667f64
    }
}
impl TriAxial for Psyche {
    fn subplanetary_radius(&self) -> f64 {
        139.5f64
    }
    fn along_orbit_radius(&self) -> f64 {
        116f64
    }
}
impl PointMass for Psyche {
    fn gravitational_parameter(&self) -> f64 {
        1.5896582441709424f64
    }
}
#[allow(clippy::approx_constant)]
impl RotationalElements for Psyche {
    fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients {
        (&[] as &[f64], &[] as &[f64])
    }
    fn right_ascension_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
    fn declination_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
    fn prime_meridian_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct Lutetia;
impl Body for Lutetia {
    fn id(&self) -> NaifId {
        NaifId(2000021i32)
    }
    fn name(&self) -> &'static str {
        "Lutetia"
    }
}
impl Display for Lutetia {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}
impl Ellipsoid for Lutetia {
    fn polar_radius(&self) -> f64 {
        46.5f64
    }
    fn mean_radius(&self) -> f64 {
        53f64
    }
}
impl TriAxial for Lutetia {
    fn subplanetary_radius(&self) -> f64 {
        62f64
    }
    fn along_orbit_radius(&self) -> f64 {
        50.5f64
    }
}
#[allow(clippy::approx_constant)]
impl RotationalElements for Lutetia {
    fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients {
        (&[] as &[f64], &[] as &[f64])
    }
    fn right_ascension_coefficients(&self) -> PolynomialCoefficients {
        (0.9075712110370514f64, 0f64, 0f64, &[] as &[f64])
    }
    fn declination_coefficients(&self) -> PolynomialCoefficients {
        (0.20943951023931956f64, 0f64, 0f64, &[] as &[f64])
    }
    fn prime_meridian_coefficients(&self) -> PolynomialCoefficients {
        (
            1.6406094968746698f64,
            18.4612463429088f64,
            0f64,
            &[] as &[f64],
        )
    }
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct Kleopatra;
impl Body for Kleopatra {
    fn id(&self) -> NaifId {
        NaifId(2000216i32)
    }
    fn name(&self) -> &'static str {
        "Kleopatra"
    }
}
impl Display for Kleopatra {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}
#[allow(clippy::approx_constant)]
impl RotationalElements for Kleopatra {
    fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients {
        (&[] as &[f64], &[] as &[f64])
    }
    fn right_ascension_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
    fn declination_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
    fn prime_meridian_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct Eros;
impl MinorBody for Eros {}
impl Body for Eros {
    fn id(&self) -> NaifId {
        NaifId(2000433i32)
    }
    fn name(&self) -> &'static str {
        "Eros"
    }
}
impl Display for Eros {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}
impl Ellipsoid for Eros {
    fn polar_radius(&self) -> f64 {
        5.5f64
    }
    fn mean_radius(&self) -> f64 {
        9.333333333333334f64
    }
}
impl TriAxial for Eros {
    fn subplanetary_radius(&self) -> f64 {
        17f64
    }
    fn along_orbit_radius(&self) -> f64 {
        5.5f64
    }
}
impl PointMass for Eros {
    fn gravitational_parameter(&self) -> f64 {
        0.0004463f64
    }
}
#[allow(clippy::approx_constant)]
impl RotationalElements for Eros {
    fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients {
        (&[] as &[f64], &[] as &[f64])
    }
    fn right_ascension_coefficients(&self) -> PolynomialCoefficients {
        (0.1980948701013564f64, 0f64, 0f64, &[] as &[f64])
    }
    fn declination_coefficients(&self) -> PolynomialCoefficients {
        (0.30054569719342356f64, 0f64, 0f64, &[] as &[f64])
    }
    fn prime_meridian_coefficients(&self) -> PolynomialCoefficients {
        (
            5.690995091977911f64,
            28.612729617819042f64,
            0f64,
            &[] as &[f64],
        )
    }
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct Davida;
impl MinorBody for Davida {}
impl Body for Davida {
    fn id(&self) -> NaifId {
        NaifId(2000511i32)
    }
    fn name(&self) -> &'static str {
        "Davida"
    }
}
impl Display for Davida {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}
impl Ellipsoid for Davida {
    fn polar_radius(&self) -> f64 {
        127f64
    }
    fn mean_radius(&self) -> f64 {
        151.33333333333334f64
    }
}
impl TriAxial for Davida {
    fn subplanetary_radius(&self) -> f64 {
        180f64
    }
    fn along_orbit_radius(&self) -> f64 {
        147f64
    }
}
impl PointMass for Davida {
    fn gravitational_parameter(&self) -> f64 {
        3.8944831481705644f64
    }
}
#[allow(clippy::approx_constant)]
impl RotationalElements for Davida {
    fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients {
        (&[] as &[f64], &[] as &[f64])
    }
    fn right_ascension_coefficients(&self) -> PolynomialCoefficients {
        (5.183627878423159f64, 0f64, 0f64, &[] as &[f64])
    }
    fn declination_coefficients(&self) -> PolynomialCoefficients {
        (0.08726646259971647f64, 0f64, 0f64, &[] as &[f64])
    }
    fn prime_meridian_coefficients(&self) -> PolynomialCoefficients {
        (
            4.679227724596798f64,
            29.39866372732388f64,
            0f64,
            &[] as &[f64],
        )
    }
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct Mathilde;
impl Body for Mathilde {
    fn id(&self) -> NaifId {
        NaifId(2000253i32)
    }
    fn name(&self) -> &'static str {
        "Mathilde"
    }
}
impl Display for Mathilde {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}
impl Ellipsoid for Mathilde {
    fn polar_radius(&self) -> f64 {
        23f64
    }
    fn mean_radius(&self) -> f64 {
        26.666666666666668f64
    }
}
impl TriAxial for Mathilde {
    fn subplanetary_radius(&self) -> f64 {
        33f64
    }
    fn along_orbit_radius(&self) -> f64 {
        24f64
    }
}
#[allow(clippy::approx_constant)]
impl RotationalElements for Mathilde {
    fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients {
        (&[] as &[f64], &[] as &[f64])
    }
    fn right_ascension_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
    fn declination_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
    fn prime_meridian_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct Steins;
impl Body for Steins {
    fn id(&self) -> NaifId {
        NaifId(2002867i32)
    }
    fn name(&self) -> &'static str {
        "Steins"
    }
}
impl Display for Steins {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}
impl Ellipsoid for Steins {
    fn polar_radius(&self) -> f64 {
        2.04f64
    }
    fn mean_radius(&self) -> f64 {
        2.6700000000000004f64
    }
}
impl TriAxial for Steins {
    fn subplanetary_radius(&self) -> f64 {
        3.24f64
    }
    fn along_orbit_radius(&self) -> f64 {
        2.73f64
    }
}
#[allow(clippy::approx_constant)]
impl RotationalElements for Steins {
    fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients {
        (&[] as &[f64], &[] as &[f64])
    }
    fn right_ascension_coefficients(&self) -> PolynomialCoefficients {
        (1.5882496193148399f64, 0f64, 0f64, &[] as &[f64])
    }
    fn declination_coefficients(&self) -> PolynomialCoefficients {
        (-1.0821041362364843f64, 0f64, 0f64, &[] as &[f64])
    }
    fn prime_meridian_coefficients(&self) -> PolynomialCoefficients {
        (
            5.615771401216954f64,
            24.925032561498227f64,
            0f64,
            &[] as &[f64],
        )
    }
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct Braille;
impl Body for Braille {
    fn id(&self) -> NaifId {
        NaifId(2009969i32)
    }
    fn name(&self) -> &'static str {
        "Braille"
    }
}
impl Display for Braille {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}
#[allow(clippy::approx_constant)]
impl RotationalElements for Braille {
    fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients {
        (&[] as &[f64], &[] as &[f64])
    }
    fn right_ascension_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
    fn declination_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
    fn prime_meridian_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct WilsonHarrington;
impl Body for WilsonHarrington {
    fn id(&self) -> NaifId {
        NaifId(2004015i32)
    }
    fn name(&self) -> &'static str {
        "Wilson-Harrington"
    }
}
impl Display for WilsonHarrington {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}
#[allow(clippy::approx_constant)]
impl RotationalElements for WilsonHarrington {
    fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients {
        (&[] as &[f64], &[] as &[f64])
    }
    fn right_ascension_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
    fn declination_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
    fn prime_meridian_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct Toutatis;
impl Body for Toutatis {
    fn id(&self) -> NaifId {
        NaifId(2004179i32)
    }
    fn name(&self) -> &'static str {
        "Toutatis"
    }
}
impl Display for Toutatis {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}
impl Ellipsoid for Toutatis {
    fn polar_radius(&self) -> f64 {
        0.85f64
    }
    fn mean_radius(&self) -> f64 {
        1.3316666666666666f64
    }
}
impl TriAxial for Toutatis {
    fn subplanetary_radius(&self) -> f64 {
        2.13f64
    }
    fn along_orbit_radius(&self) -> f64 {
        1.015f64
    }
}
#[allow(clippy::approx_constant)]
impl RotationalElements for Toutatis {
    fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients {
        (&[] as &[f64], &[] as &[f64])
    }
    fn right_ascension_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
    fn declination_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
    fn prime_meridian_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct Itokawa;
impl Body for Itokawa {
    fn id(&self) -> NaifId {
        NaifId(2025143i32)
    }
    fn name(&self) -> &'static str {
        "Itokawa"
    }
}
impl Display for Itokawa {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}
impl Ellipsoid for Itokawa {
    fn polar_radius(&self) -> f64 {
        0.104f64
    }
    fn mean_radius(&self) -> f64 {
        0.17300000000000001f64
    }
}
impl TriAxial for Itokawa {
    fn subplanetary_radius(&self) -> f64 {
        0.268f64
    }
    fn along_orbit_radius(&self) -> f64 {
        0.147f64
    }
}
#[allow(clippy::approx_constant)]
impl RotationalElements for Itokawa {
    fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients {
        (&[] as &[f64], &[] as &[f64])
    }
    fn right_ascension_coefficients(&self) -> PolynomialCoefficients {
        (1.5800465718304666f64, 0f64, 0f64, &[] as &[f64])
    }
    fn declination_coefficients(&self) -> PolynomialCoefficients {
        (-1.1571532940722404f64, 0f64, 0f64, &[] as &[f64])
    }
    fn prime_meridian_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 12.429240095029979f64, 0f64, &[] as &[f64])
    }
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct Bennu;
impl Body for Bennu {
    fn id(&self) -> NaifId {
        NaifId(2101955i32)
    }
    fn name(&self) -> &'static str {
        "Bennu"
    }
}
impl Display for Bennu {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}
#[allow(clippy::approx_constant)]
impl RotationalElements for Bennu {
    fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients {
        (&[] as &[f64], &[] as &[f64])
    }
    fn right_ascension_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
    fn declination_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
    fn prime_meridian_coefficients(&self) -> PolynomialCoefficients {
        (0f64, 0f64, 0f64, &[] as &[f64])
    }
}
#[cfg(test)]
#[allow(clippy::approx_constant)]
mod tests {
    use super::*;
    #[test]
    fn test_body_9511010() {
        assert_eq!(Gaspra.id(), NaifId(9511010i32));
        assert_eq!(Gaspra.name(), "Gaspra");
        assert_eq!(format!("{}", Gaspra), "Gaspra");
    }
    #[test]
    fn test_tri_axial_9511010() {
        assert_eq!(Gaspra.polar_radius(), 4.4f64);
        assert_eq!(Gaspra.mean_radius(), 6.233333333333334f64);
        assert_eq!(Gaspra.subplanetary_radius(), 9.1f64);
        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!(
            (0.16528268016386302f64, 0f64, 0f64, &[] as &[f64]),
            Gaspra.right_ascension_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_declination_coefficients_9511010() {
        assert_eq!(
            (0.46600291028248597f64, 0f64, 0f64, &[] as &[f64]),
            Gaspra.declination_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_prime_meridian_coefficients_9511010() {
        assert_eq!(
            (
                1.4603169851436555f64,
                21.41364504378302f64,
                0f64,
                &[] as &[f64]
            ),
            Gaspra.prime_meridian_coefficients()
        )
    }
    #[test]
    fn test_body_2431010() {
        assert_eq!(Ida.id(), NaifId(2431010i32));
        assert_eq!(Ida.name(), "Ida");
        assert_eq!(format!("{}", Ida), "Ida");
    }
    #[test]
    fn test_tri_axial_2431010() {
        assert_eq!(Ida.polar_radius(), 7.6f64);
        assert_eq!(Ida.mean_radius(), 15.466666666666667f64);
        assert_eq!(Ida.subplanetary_radius(), 26.8f64);
        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!(
            (2.9454176456656302f64, 0f64, 0f64, &[] as &[f64]),
            Ida.right_ascension_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_declination_coefficients_2431010() {
        assert_eq!(
            (-1.5205308443374599f64, 0f64, 0f64, &[] as &[f64]),
            Ida.declination_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_prime_meridian_coefficients_2431010() {
        assert_eq!(
            (
                4.78307481509046f64,
                32.54389804704987f64,
                0f64,
                &[] as &[f64]
            ),
            Ida.prime_meridian_coefficients()
        )
    }
    #[test]
    fn test_body_2431011() {
        assert_eq!(Dactyl.id(), NaifId(2431011i32));
        assert_eq!(Dactyl.name(), "Dactyl");
        assert_eq!(format!("{}", Dactyl), "Dactyl");
    }
    #[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_body_2000001() {
        assert_eq!(Ceres.id(), NaifId(2000001i32));
        assert_eq!(Ceres.name(), "Ceres");
        assert_eq!(format!("{}", Ceres), "Ceres");
    }
    #[test]
    fn test_tri_axial_2000001() {
        assert_eq!(Ceres.polar_radius(), 446f64);
        assert_eq!(Ceres.mean_radius(), 473.5333333333333f64);
        assert_eq!(Ceres.subplanetary_radius(), 487.3f64);
        assert_eq!(Ceres.along_orbit_radius(), 487.3f64);
    }
    #[test]
    fn test_point_mass_2000001() {
        assert_eq!(Ceres.gravitational_parameter(), 62.62888864440993f64);
    }
    #[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!(
            (5.0862035995768355f64, 0f64, 0f64, &[] as &[f64]),
            Ceres.right_ascension_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_declination_coefficients_2000001() {
        assert_eq!(
            (1.165251621801494f64, 0f64, 0f64, &[] as &[f64]),
            Ceres.declination_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_prime_meridian_coefficients_2000001() {
        assert_eq!(
            (
                2.9784043685283237f64,
                16.618208323400072f64,
                0f64,
                &[] as &[f64]
            ),
            Ceres.prime_meridian_coefficients()
        )
    }
    #[test]
    fn test_body_2000002() {
        assert_eq!(Pallas.id(), NaifId(2000002i32));
        assert_eq!(Pallas.name(), "Pallas");
        assert_eq!(format!("{}", Pallas), "Pallas");
    }
    #[test]
    fn test_point_mass_2000002() {
        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!(
            (0.5759586531581288f64, 0f64, 0f64, &[] as &[f64]),
            Pallas.right_ascension_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_declination_coefficients_2000002() {
        assert_eq!(
            (-0.05235987755982989f64, 0f64, 0f64, &[] as &[f64]),
            Pallas.declination_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_prime_meridian_coefficients_2000002() {
        assert_eq!(
            (
                0.6632251157578453f64,
                19.299913700406368f64,
                0f64,
                &[] as &[f64]
            ),
            Pallas.prime_meridian_coefficients()
        )
    }
    #[test]
    fn test_body_2000004() {
        assert_eq!(Vesta.id(), NaifId(2000004i32));
        assert_eq!(Vesta.name(), "Vesta");
        assert_eq!(format!("{}", Vesta), "Vesta");
    }
    #[test]
    fn test_tri_axial_2000004() {
        assert_eq!(Vesta.polar_radius(), 229f64);
        assert_eq!(Vesta.mean_radius(), 266f64);
        assert_eq!(Vesta.subplanetary_radius(), 289f64);
        assert_eq!(Vesta.along_orbit_radius(), 280f64);
    }
    #[test]
    fn test_point_mass_2000004() {
        assert_eq!(Vesta.gravitational_parameter(), 17.288232879171513f64);
    }
    #[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!(
            (5.393608440730596f64, 0f64, 0f64, &[] as &[f64]),
            Vesta.right_ascension_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_declination_coefficients_2000004() {
        assert_eq!(
            (0.7371398095798051f64, 0f64, 0f64, &[] as &[f64]),
            Vesta.declination_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_prime_meridian_coefficients_2000004() {
        assert_eq!(
            (
                4.980995152266617f64,
                28.22778495282912f64,
                0f64,
                &[] as &[f64]
            ),
            Vesta.prime_meridian_coefficients()
        )
    }
    #[test]
    fn test_body_2000016() {
        assert_eq!(Psyche.id(), NaifId(2000016i32));
        assert_eq!(Psyche.name(), "Psyche");
        assert_eq!(format!("{}", Psyche), "Psyche");
    }
    #[test]
    fn test_tri_axial_2000016() {
        assert_eq!(Psyche.polar_radius(), 94.5f64);
        assert_eq!(Psyche.mean_radius(), 116.66666666666667f64);
        assert_eq!(Psyche.subplanetary_radius(), 139.5f64);
        assert_eq!(Psyche.along_orbit_radius(), 116f64);
    }
    #[test]
    fn test_point_mass_2000016() {
        assert_eq!(Psyche.gravitational_parameter(), 1.5896582441709424f64);
    }
    #[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_body_2000021() {
        assert_eq!(Lutetia.id(), NaifId(2000021i32));
        assert_eq!(Lutetia.name(), "Lutetia");
        assert_eq!(format!("{}", Lutetia), "Lutetia");
    }
    #[test]
    fn test_tri_axial_2000021() {
        assert_eq!(Lutetia.polar_radius(), 46.5f64);
        assert_eq!(Lutetia.mean_radius(), 53f64);
        assert_eq!(Lutetia.subplanetary_radius(), 62f64);
        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!(
            (0.9075712110370514f64, 0f64, 0f64, &[] as &[f64]),
            Lutetia.right_ascension_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_declination_coefficients_2000021() {
        assert_eq!(
            (0.20943951023931956f64, 0f64, 0f64, &[] as &[f64]),
            Lutetia.declination_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_prime_meridian_coefficients_2000021() {
        assert_eq!(
            (
                1.6406094968746698f64,
                18.4612463429088f64,
                0f64,
                &[] as &[f64]
            ),
            Lutetia.prime_meridian_coefficients()
        )
    }
    #[test]
    fn test_body_2000216() {
        assert_eq!(Kleopatra.id(), NaifId(2000216i32));
        assert_eq!(Kleopatra.name(), "Kleopatra");
        assert_eq!(format!("{}", Kleopatra), "Kleopatra");
    }
    #[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_body_2000433() {
        assert_eq!(Eros.id(), NaifId(2000433i32));
        assert_eq!(Eros.name(), "Eros");
        assert_eq!(format!("{}", Eros), "Eros");
    }
    #[test]
    fn test_tri_axial_2000433() {
        assert_eq!(Eros.polar_radius(), 5.5f64);
        assert_eq!(Eros.mean_radius(), 9.333333333333334f64);
        assert_eq!(Eros.subplanetary_radius(), 17f64);
        assert_eq!(Eros.along_orbit_radius(), 5.5f64);
    }
    #[test]
    fn test_point_mass_2000433() {
        assert_eq!(Eros.gravitational_parameter(), 0.0004463f64);
    }
    #[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!(
            (0.1980948701013564f64, 0f64, 0f64, &[] as &[f64]),
            Eros.right_ascension_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_declination_coefficients_2000433() {
        assert_eq!(
            (0.30054569719342356f64, 0f64, 0f64, &[] as &[f64]),
            Eros.declination_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_prime_meridian_coefficients_2000433() {
        assert_eq!(
            (
                5.690995091977911f64,
                28.612729617819042f64,
                0f64,
                &[] as &[f64]
            ),
            Eros.prime_meridian_coefficients()
        )
    }
    #[test]
    fn test_body_2000511() {
        assert_eq!(Davida.id(), NaifId(2000511i32));
        assert_eq!(Davida.name(), "Davida");
        assert_eq!(format!("{}", Davida), "Davida");
    }
    #[test]
    fn test_tri_axial_2000511() {
        assert_eq!(Davida.polar_radius(), 127f64);
        assert_eq!(Davida.mean_radius(), 151.33333333333334f64);
        assert_eq!(Davida.subplanetary_radius(), 180f64);
        assert_eq!(Davida.along_orbit_radius(), 147f64);
    }
    #[test]
    fn test_point_mass_2000511() {
        assert_eq!(Davida.gravitational_parameter(), 3.8944831481705644f64);
    }
    #[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!(
            (5.183627878423159f64, 0f64, 0f64, &[] as &[f64]),
            Davida.right_ascension_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_declination_coefficients_2000511() {
        assert_eq!(
            (0.08726646259971647f64, 0f64, 0f64, &[] as &[f64]),
            Davida.declination_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_prime_meridian_coefficients_2000511() {
        assert_eq!(
            (
                4.679227724596798f64,
                29.39866372732388f64,
                0f64,
                &[] as &[f64]
            ),
            Davida.prime_meridian_coefficients()
        )
    }
    #[test]
    fn test_body_2000253() {
        assert_eq!(Mathilde.id(), NaifId(2000253i32));
        assert_eq!(Mathilde.name(), "Mathilde");
        assert_eq!(format!("{}", Mathilde), "Mathilde");
    }
    #[test]
    fn test_tri_axial_2000253() {
        assert_eq!(Mathilde.polar_radius(), 23f64);
        assert_eq!(Mathilde.mean_radius(), 26.666666666666668f64);
        assert_eq!(Mathilde.subplanetary_radius(), 33f64);
        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_body_2002867() {
        assert_eq!(Steins.id(), NaifId(2002867i32));
        assert_eq!(Steins.name(), "Steins");
        assert_eq!(format!("{}", Steins), "Steins");
    }
    #[test]
    fn test_tri_axial_2002867() {
        assert_eq!(Steins.polar_radius(), 2.04f64);
        assert_eq!(Steins.mean_radius(), 2.6700000000000004f64);
        assert_eq!(Steins.subplanetary_radius(), 3.24f64);
        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!(
            (1.5882496193148399f64, 0f64, 0f64, &[] as &[f64]),
            Steins.right_ascension_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_declination_coefficients_2002867() {
        assert_eq!(
            (-1.0821041362364843f64, 0f64, 0f64, &[] as &[f64]),
            Steins.declination_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_prime_meridian_coefficients_2002867() {
        assert_eq!(
            (
                5.615771401216954f64,
                24.925032561498227f64,
                0f64,
                &[] as &[f64]
            ),
            Steins.prime_meridian_coefficients()
        )
    }
    #[test]
    fn test_body_2009969() {
        assert_eq!(Braille.id(), NaifId(2009969i32));
        assert_eq!(Braille.name(), "Braille");
        assert_eq!(format!("{}", Braille), "Braille");
    }
    #[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_body_2004015() {
        assert_eq!(WilsonHarrington.id(), NaifId(2004015i32));
        assert_eq!(WilsonHarrington.name(), "Wilson-Harrington");
        assert_eq!(format!("{}", WilsonHarrington), "Wilson-Harrington");
    }
    #[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_body_2004179() {
        assert_eq!(Toutatis.id(), NaifId(2004179i32));
        assert_eq!(Toutatis.name(), "Toutatis");
        assert_eq!(format!("{}", Toutatis), "Toutatis");
    }
    #[test]
    fn test_tri_axial_2004179() {
        assert_eq!(Toutatis.polar_radius(), 0.85f64);
        assert_eq!(Toutatis.mean_radius(), 1.3316666666666666f64);
        assert_eq!(Toutatis.subplanetary_radius(), 2.13f64);
        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_body_2025143() {
        assert_eq!(Itokawa.id(), NaifId(2025143i32));
        assert_eq!(Itokawa.name(), "Itokawa");
        assert_eq!(format!("{}", Itokawa), "Itokawa");
    }
    #[test]
    fn test_tri_axial_2025143() {
        assert_eq!(Itokawa.polar_radius(), 0.104f64);
        assert_eq!(Itokawa.mean_radius(), 0.17300000000000001f64);
        assert_eq!(Itokawa.subplanetary_radius(), 0.268f64);
        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!(
            (1.5800465718304666f64, 0f64, 0f64, &[] as &[f64]),
            Itokawa.right_ascension_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_declination_coefficients_2025143() {
        assert_eq!(
            (-1.1571532940722404f64, 0f64, 0f64, &[] as &[f64]),
            Itokawa.declination_coefficients()
        )
    }
    #[test]
    fn test_rotational_elements_prime_meridian_coefficients_2025143() {
        assert_eq!(
            (0f64, 12.429240095029979f64, 0f64, &[] as &[f64]),
            Itokawa.prime_meridian_coefficients()
        )
    }
    #[test]
    fn test_body_2101955() {
        assert_eq!(Bennu.id(), NaifId(2101955i32));
        assert_eq!(Bennu.name(), "Bennu");
        assert_eq!(format!("{}", Bennu), "Bennu");
    }
    #[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()
        )
    }
}
