From 774096b45ca0431d24bc2aa727265fddc81995ce Mon Sep 17 00:00:00 2001 From: Helge Eichhorn Date: Tue, 3 Dec 2024 09:54:51 +0100 Subject: [PATCH] refactor: implement dynamic origin and frame types --- .github/workflows/python.yml | 32 +- Cargo.lock | 67 +- Cargo.toml | 14 +- crates/lox-bodies/Cargo.toml | 2 + crates/lox-bodies/src/dynamic.rs | 876 + crates/lox-bodies/src/errors.rs | 15 - .../lox-bodies/src/fundamental/simon1994.rs | 2 +- crates/lox-bodies/src/generated.rs | 9731 +++++- .../lox-bodies/src/generated/barycenters.rs | 339 - crates/lox-bodies/src/generated/minor.rs | 1597 - crates/lox-bodies/src/generated/planets.rs | 1851 -- crates/lox-bodies/src/generated/satellites.rs | 25773 ---------------- crates/lox-bodies/src/generated/sun.rs | 122 - crates/lox-bodies/src/lib.rs | 901 +- crates/lox-bodies/src/python.rs | 812 +- crates/lox-earth/src/cio.rs | 2 +- crates/lox-earth/src/lib.rs | 18 +- crates/lox-orbits/Cargo.toml | 4 +- crates/lox-orbits/src/analysis.rs | 105 +- crates/lox-orbits/src/elements.rs | 111 +- crates/lox-orbits/src/ensembles.rs | 2 +- crates/lox-orbits/src/frames.rs | 341 +- crates/lox-orbits/src/frames/iau.rs | 64 + crates/lox-orbits/src/frames/iers.rs | 42 + crates/lox-orbits/src/ground.rs | 152 +- crates/lox-orbits/src/lib.rs | 1 - crates/lox-orbits/src/origins.rs | 9 - crates/lox-orbits/src/propagators.rs | 3 +- .../src/propagators/semi_analytical.rs | 80 +- crates/lox-orbits/src/propagators/sgp4.rs | 2 - crates/lox-orbits/src/python.rs | 573 +- crates/lox-orbits/src/python/.gitkeep | 0 crates/lox-orbits/src/python/generated.rs | 7814 ----- crates/lox-orbits/src/rotations.rs | 20 + crates/lox-orbits/src/states.rs | 403 +- crates/lox-orbits/src/trajectories.rs | 55 +- crates/lox-space/benches/iau_frames.rs | 8 +- crates/lox-space/benches/observables.rs | 26 +- crates/lox-space/examples/iss.rs | 1 - crates/lox-space/lox_space.pyi | 53 +- crates/lox-space/pyproject.toml | 2 +- crates/lox-space/src/lib.rs | 16 +- crates/lox-space/tests/conftest.py | 2 +- crates/lox-space/tests/test_pickle.py | 19 +- crates/lox-space/tests/test_propagators.py | 8 +- crates/lox-space/tests/test_states.py | 22 +- crates/lox-time/src/lib.rs | 6 +- crates/lox-time/src/python/deltas.rs | 2 +- crates/lox-time/src/python/time.rs | 16 +- crates/lox-time/src/python/utc.rs | 4 +- data/pck00011_n0066.tpc | 4354 +++ tools/lox-gen/Cargo.lock | 50 +- tools/lox-gen/Cargo.toml | 8 +- tools/lox-gen/src/bodies.rs | 27 - tools/lox-gen/src/common.rs | 18 + tools/lox-gen/src/frames.rs | 1314 - tools/lox-gen/src/generators.rs | 258 - tools/lox-gen/src/main.rs | 18 +- tools/lox-gen/src/modules.rs | 1092 - tools/lox-gen/src/origins.rs | 1341 + tools/lox-gen/src/rotational_elements.rs | 345 - 61 files changed, 18029 insertions(+), 42916 deletions(-) create mode 100644 crates/lox-bodies/src/dynamic.rs delete mode 100644 crates/lox-bodies/src/errors.rs delete mode 100644 crates/lox-bodies/src/generated/barycenters.rs delete mode 100644 crates/lox-bodies/src/generated/minor.rs delete mode 100644 crates/lox-bodies/src/generated/planets.rs delete mode 100644 crates/lox-bodies/src/generated/satellites.rs delete mode 100644 crates/lox-bodies/src/generated/sun.rs create mode 100644 crates/lox-orbits/src/frames/iau.rs create mode 100644 crates/lox-orbits/src/frames/iers.rs delete mode 100644 crates/lox-orbits/src/origins.rs delete mode 100644 crates/lox-orbits/src/python/.gitkeep delete mode 100644 crates/lox-orbits/src/python/generated.rs create mode 100644 data/pck00011_n0066.tpc delete mode 100644 tools/lox-gen/src/bodies.rs delete mode 100644 tools/lox-gen/src/frames.rs delete mode 100644 tools/lox-gen/src/generators.rs delete mode 100644 tools/lox-gen/src/modules.rs create mode 100644 tools/lox-gen/src/origins.rs delete mode 100644 tools/lox-gen/src/rotational_elements.rs diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml index 57bffaa6..b557a1d5 100644 --- a/.github/workflows/python.yml +++ b/.github/workflows/python.yml @@ -24,9 +24,9 @@ jobs: strategy: matrix: platform: - - runner: ubuntu-latest + - runner: ubuntu-22.04 target: x86_64 - - runner: ubuntu-latest + - runner: ubuntu-22.04 target: x86 - runner: ubuntu-latest target: aarch64 @@ -35,11 +35,13 @@ jobs: - uses: actions/setup-python@v5 with: python-version: 3.x + - name: Install uv + uses: astral-sh/setup-uv@v4 - name: Build wheels uses: PyO3/maturin-action@v1 with: target: ${{ matrix.platform.target }} - args: --release --out dist --find-interpreter --manifest-path crates/lox-space/Cargo.toml + args: --release --out dist -i 3.9 -i 3.10 -i 3.11 -i 3.12 --manifest-path crates/lox-space/Cargo.toml sccache: 'true' manylinux: auto - name: Upload wheels @@ -54,8 +56,8 @@ jobs: set -e python3 -m venv .venv source .venv/bin/activate - pip install lox-space --find-links dist --force-reinstall - pip install pytest + uv pip install lox-space --find-links dist --force-reinstall + uv pip install pytest pytest-codspeed cd crates/lox-space && pytest - name: pytest if: ${{ !startsWith(matrix.platform.target, 'x86') && matrix.platform.target != 'ppc64' }} @@ -66,11 +68,15 @@ jobs: githubToken: ${{ github.token }} install: | apt-get update - apt-get install -y --no-install-recommends python3 python3-pip - pip3 install -U pip pytest pytest-codspeed + apt-get install -y curl + curl -LsSf https://astral.sh/uv/install.sh | sh run: | set -e - pip3 install lox-space --find-links dist --force-reinstall + source $HOME/.local/bin/env + uv venv --python 3.12 + uv pip install pytest pytest-codspeed + uv pip install lox-space --find-links dist --force-reinstall + source .venv/bin/activate cd crates/lox-space && pytest windows: @@ -106,8 +112,8 @@ jobs: set -e python3 -m venv .venv source .venv/Scripts/activate - pip install lox-space --find-links dist --force-reinstall - pip install pytest + pip install lox-space --find-links dist --force-reinstall + pip install pytest pytest-codspeed cd crates/lox-space && pytest macos: @@ -123,7 +129,7 @@ jobs: - uses: actions/checkout@v4 - uses: actions/setup-python@v5 with: - python-version: 3.12 + python-version: 3.x - name: Build wheels uses: PyO3/maturin-action@v1 with: @@ -140,8 +146,8 @@ jobs: set -e python3 -m venv .venv source .venv/bin/activate - pip install lox-space --find-links dist --force-reinstall - pip install pytest + pip install lox-space --find-links dist --force-reinstall + pip install pytest pytest-codspeed cd crates/lox-space && pytest sdist: diff --git a/Cargo.lock b/Cargo.lock index 4d42e725..7e5a2258 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -213,9 +213,9 @@ dependencies = [ [[package]] name = "fast_polynomial" -version = "0.1.0" +version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "831e16abe0108eef0005da4a921664c9c15707301148c30ecfc5c9ae4b3fdeda" +checksum = "62eea6ee590b08a5f8b1139f4d6caee195b646d0c07e4b1808fbd5c4dea4829a" dependencies = [ "num-traits", ] @@ -346,9 +346,9 @@ dependencies = [ [[package]] name = "glam" -version = "0.28.0" +version = "0.29.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "779ae4bf7e8421cf91c0b3b64e7e8b40b862fba4d393f59150042de7c4965a94" +checksum = "dc46dd3ec48fdd8e693a98d2b8bafae273a2d54c1de02a2a7e3d57d501f39677" [[package]] name = "glob" @@ -469,6 +469,8 @@ dependencies = [ "fast_polynomial", "float_eq", "lox-math", + "num-derive", + "num-traits", "pyo3", "rstest", "thiserror", @@ -548,11 +550,13 @@ dependencies = [ "itertools", "libm", "lox-bodies", + "lox-earth", "lox-ephem", "lox-math", "lox-time", "numpy", "pyo3", + "rstest", "sgp4", "thiserror", ] @@ -675,6 +679,17 @@ dependencies = [ "num-traits", ] +[[package]] +name = "num-derive" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "num-integer" version = "0.1.46" @@ -718,9 +733,9 @@ dependencies = [ [[package]] name = "numpy" -version = "0.22.1" +version = "0.23.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "edb929bc0da91a4d85ed6c0a84deaa53d411abfb387fc271124f91bf6b89f14e" +checksum = "b94caae805f998a07d33af06e6a3891e38556051b8045c615470a71590e13e78" dependencies = [ "libc", "ndarray", @@ -813,9 +828,9 @@ dependencies = [ [[package]] name = "pyo3" -version = "0.22.6" +version = "0.23.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f402062616ab18202ae8319da13fa4279883a2b8a9d9f83f20dbade813ce1884" +checksum = "e484fd2c8b4cb67ab05a318f1fd6fa8f199fcc30819f08f07d200809dba26c15" dependencies = [ "cfg-if", "indoc", @@ -831,9 +846,9 @@ dependencies = [ [[package]] name = "pyo3-build-config" -version = "0.22.6" +version = "0.23.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b14b5775b5ff446dd1056212d778012cbe8a0fbffd368029fd9e25b514479c38" +checksum = "dc0e0469a84f208e20044b98965e1561028180219e35352a2afaf2b942beff3b" dependencies = [ "once_cell", "target-lexicon", @@ -841,9 +856,9 @@ dependencies = [ [[package]] name = "pyo3-ffi" -version = "0.22.6" +version = "0.23.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9ab5bcf04a2cdcbb50c7d6105de943f543f9ed92af55818fd17b660390fc8636" +checksum = "eb1547a7f9966f6f1a0f0227564a9945fe36b90da5a93b3933fc3dc03fae372d" dependencies = [ "libc", "pyo3-build-config", @@ -851,9 +866,9 @@ dependencies = [ [[package]] name = "pyo3-macros" -version = "0.22.6" +version = "0.23.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fd24d897903a9e6d80b968368a34e1525aeb719d568dba8b3d4bfa5dc67d453" +checksum = "fdb6da8ec6fa5cedd1626c886fc8749bdcbb09424a86461eb8cdf096b7c33257" dependencies = [ "proc-macro2", "pyo3-macros-backend", @@ -863,9 +878,9 @@ dependencies = [ [[package]] name = "pyo3-macros-backend" -version = "0.22.6" +version = "0.23.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36c011a03ba1e50152b4b394b479826cad97e7a21eb52df179cd91ac411cbfbe" +checksum = "38a385202ff5a92791168b1136afae5059d3ac118457bb7bc304c197c2d33e7d" dependencies = [ "heck", "proc-macro2", @@ -987,9 +1002,9 @@ checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2" [[package]] name = "rstest" -version = "0.21.0" +version = "0.23.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9afd55a67069d6e434a95161415f5beeada95a01c7b815508a82dcb0e1593682" +checksum = "0a2c585be59b6b5dd66a9d2084aa1d8bd52fbdb806eafdeffb52791147862035" dependencies = [ "futures", "futures-timer", @@ -999,9 +1014,9 @@ dependencies = [ [[package]] name = "rstest_macros" -version = "0.21.0" +version = "0.23.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4165dfae59a39dd41d8dec720d3cbfbc71f69744efb480a3920f5d4e0cc6798d" +checksum = "825ea780781b15345a146be27eaefb05085e337e869bff01b4306a4fd4a9ad5a" dependencies = [ "cfg-if", "glob", @@ -1017,9 +1032,9 @@ dependencies = [ [[package]] name = "rustc-hash" -version = "1.1.0" +version = "2.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" +checksum = "c7fb8039b3032c191086b10f11f319a6e99e1e82889c5cc6046f515c9db1d497" [[package]] name = "rustc_version" @@ -1178,18 +1193,18 @@ dependencies = [ [[package]] name = "thiserror" -version = "1.0.69" +version = "2.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +checksum = "c006c85c7651b3cf2ada4584faa36773bd07bac24acfb39f3c431b36d7e667aa" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.69" +version = "2.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +checksum = "f077553d607adc1caf65430528a576c757a71ed73944b66ebb58ef2bbd243568" dependencies = [ "proc-macro2", "quote", diff --git a/Cargo.toml b/Cargo.toml index e0dcc312..3fb994c5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -24,21 +24,23 @@ lox-time = { path = "crates/lox-time", version = "0.1.0-alpha.1" } csv = "1.3.0" divan = "0.1.14" dyn-clone = "1.0.17" -fast_polynomial = "0.1.0" +fast_polynomial = "0.3.0" float_eq = "1.0.1" -glam = "0.28.0" +glam = "0.29.2" itertools = "0.13.0" libm = "0.2.8" nom = "7.1.3" num = "0.4.1" -numpy = "0.22.1" +num-derive = "0.4.2" +num-traits = "0.2.19" +numpy = "0.23.0" proptest = "1.4.0" -pyo3 = "0.22.6" +pyo3 = "0.23.3" quick-xml = { version = "0.31.0", features = ["serde", "serialize"] } regex = "1.10.4" -rstest = "0.21.0" +rstest = "0.23.0" serde = { version = "1.0.199", features = ["derive"] } serde-aux = "4.5.0" serde_json = "1.0.113" sgp4 = "2.2.0" -thiserror = "1.0" +thiserror = "2.0.3" diff --git a/crates/lox-bodies/Cargo.toml b/crates/lox-bodies/Cargo.toml index dde2f74e..2da51537 100644 --- a/crates/lox-bodies/Cargo.toml +++ b/crates/lox-bodies/Cargo.toml @@ -13,6 +13,8 @@ lox-math.workspace = true dyn-clone.workspace = true fast_polynomial.workspace = true +num-derive.workspace = true +num-traits.workspace = true pyo3 = { workspace = true, optional = true } thiserror.workspace = true diff --git a/crates/lox-bodies/src/dynamic.rs b/crates/lox-bodies/src/dynamic.rs new file mode 100644 index 00000000..c7e8aff4 --- /dev/null +++ b/crates/lox-bodies/src/dynamic.rs @@ -0,0 +1,876 @@ +use crate::{NaifId, Origin}; +use num_derive::{FromPrimitive, ToPrimitive}; +use num_traits::{FromPrimitive, ToPrimitive}; +use std::fmt::{Display, Formatter}; +use std::str::FromStr; +use thiserror::Error; + +#[derive(Debug, Clone, Eq, PartialEq, Error)] +#[error("no origin with name `{0}` is known")] +pub struct UnknownOriginName(String); + +#[derive(Debug, Clone, Eq, PartialEq, Error)] +#[error("no origin with NAIF ID `{0}` is known")] +pub struct UnknownOriginId(i32); + +#[derive( + Debug, Copy, Clone, Default, Eq, PartialEq, Hash, FromPrimitive, ToPrimitive, PartialOrd, Ord, +)] +pub enum DynOrigin { + Sun = 10, + + // Planets. + Mercury = 199, + Venus = 299, + #[default] + Earth = 399, + Mars = 499, + Jupiter = 599, + Saturn = 699, + Uranus = 799, + Neptune = 899, + Pluto = 999, + + // Barycenters. + SolarSystemBarycenter = 0, + MercuryBarycenter = 1, + VenusBarycenter = 2, + EarthBarycenter = 3, + MarsBarycenter = 4, + JupiterBarycenter = 5, + SaturnBarycenter = 6, + UranusBarycenter = 7, + NeptuneBarycenter = 8, + PlutoBarycenter = 9, + + // Satellites. + Moon = 301, + Phobos = 401, + Deimos = 402, + Io = 501, + Europa = 502, + Ganymede = 503, + Callisto = 504, + Amalthea = 505, + Himalia = 506, + Elara = 507, + Pasiphae = 508, + Sinope = 509, + Lysithea = 510, + Carme = 511, + Ananke = 512, + Leda = 513, + Thebe = 514, + Adrastea = 515, + Metis = 516, + Callirrhoe = 517, + Themisto = 518, + Magaclite = 519, + Taygete = 520, + Chaldene = 521, + Harpalyke = 522, + Kalyke = 523, + Iocaste = 524, + Erinome = 525, + Isonoe = 526, + Praxidike = 527, + Autonoe = 528, + Thyone = 529, + Hermippe = 530, + Aitne = 531, + Eurydome = 532, + Euanthe = 533, + Euporie = 534, + Orthosie = 535, + Sponde = 536, + Kale = 537, + Pasithee = 538, + Hegemone = 539, + Mneme = 540, + Aoede = 541, + Thelxinoe = 542, + Arche = 543, + Kallichore = 544, + Helike = 545, + Carpo = 546, + Eukelade = 547, + Cyllene = 548, + Kore = 549, + Herse = 550, + Dia = 553, + Mimas = 601, + Enceladus = 602, + Tethys = 603, + Dione = 604, + Rhea = 605, + Titan = 606, + Hyperion = 607, + Iapetus = 608, + Phoebe = 609, + Janus = 610, + Epimetheus = 611, + Helene = 612, + Telesto = 613, + Calypso = 614, + Atlas = 615, + Prometheus = 616, + Pandora = 617, + Pan = 618, + Ymir = 619, + Paaliaq = 620, + Tarvos = 621, + Ijiraq = 622, + Suttungr = 623, + Kiviuq = 624, + Mundilfari = 625, + Albiorix = 626, + Skathi = 627, + Erriapus = 628, + Siarnaq = 629, + Thrymr = 630, + Narvi = 631, + Methone = 632, + Pallene = 633, + Polydeuces = 634, + Daphnis = 635, + Aegir = 636, + Bebhionn = 637, + Bergelmir = 638, + Bestla = 639, + Farbauti = 640, + Fenrir = 641, + Fornjot = 642, + Hati = 643, + Hyrrokkin = 644, + Kari = 645, + Loge = 646, + Skoll = 647, + Surtur = 648, + Anthe = 649, + Jarnsaxa = 650, + Greip = 651, + Tarqeq = 652, + Aegaeon = 653, + Ariel = 701, + Umbriel = 702, + Titania = 703, + Oberon = 704, + Miranda = 705, + Cordelia = 706, + Ophelia = 707, + Bianca = 708, + Cressida = 709, + Desdemona = 710, + Juliet = 711, + Portia = 712, + Rosalind = 713, + Belinda = 714, + Puck = 715, + Caliban = 716, + Sycorax = 717, + Prospero = 718, + Setebos = 719, + Stephano = 720, + Trinculo = 721, + Francisco = 722, + Margaret = 723, + Ferdinand = 724, + Perdita = 725, + Mab = 726, + Cupid = 727, + Triton = 801, + Nereid = 802, + Naiad = 803, + Thalassa = 804, + Despina = 805, + Galatea = 806, + Larissa = 807, + Proteus = 808, + Halimede = 809, + Psamathe = 810, + Sao = 811, + Laomedeia = 812, + Neso = 813, + Charon = 901, + Nix = 902, + Hydra = 903, + Kerberos = 904, + Styx = 905, + + // Minor bodies. + Gaspra = 9511010, + Ida = 2431010, + Dactyl = 2431011, + Ceres = 2000001, + Pallas = 2000002, + Vesta = 2000004, + Psyche = 2000016, + Lutetia = 2000021, + Kleopatra = 2000216, + Eros = 2000433, + Davida = 2000511, + Mathilde = 2000253, + Steins = 2002867, + Braille = 2009969, + WilsonHarrington = 2004015, + Toutatis = 2004179, + Itokawa = 2025143, + Bennu = 2101955, +} + +impl Origin for DynOrigin { + fn id(&self) -> NaifId { + NaifId(self.to_i32().unwrap()) + } + + fn name(&self) -> &'static str { + match self { + DynOrigin::Sun => "Sun", + + // Planets. + DynOrigin::Mercury => "Mercury", + DynOrigin::Venus => "Venus", + DynOrigin::Earth => "Earth", + DynOrigin::Mars => "Mars", + DynOrigin::Jupiter => "Jupiter", + DynOrigin::Saturn => "Saturn", + DynOrigin::Uranus => "Uranus", + DynOrigin::Neptune => "Neptune", + DynOrigin::Pluto => "Pluto", + + // Barycenters. + DynOrigin::SolarSystemBarycenter => "Solar System Barycenter", + DynOrigin::MercuryBarycenter => "Mercury Barycenter", + DynOrigin::VenusBarycenter => "Venus Barycenter", + DynOrigin::EarthBarycenter => "Earth Barycenter", + DynOrigin::MarsBarycenter => "Mars Barycenter", + DynOrigin::JupiterBarycenter => "Jupiter Barycenter", + DynOrigin::SaturnBarycenter => "Saturn Barycenter", + DynOrigin::UranusBarycenter => "Uranus Barycenter", + DynOrigin::NeptuneBarycenter => "Neptune Barycenter", + DynOrigin::PlutoBarycenter => "Pluto Barycenter", + + // Satellites. + DynOrigin::Moon => "Moon", + DynOrigin::Phobos => "Phobos", + DynOrigin::Deimos => "Deimos", + DynOrigin::Io => "Io", + DynOrigin::Europa => "Europa", + DynOrigin::Ganymede => "Ganymede", + DynOrigin::Callisto => "Callisto", + DynOrigin::Amalthea => "Amalthea", + DynOrigin::Himalia => "Himalia", + DynOrigin::Elara => "Elara", + DynOrigin::Pasiphae => "Pasiphae", + DynOrigin::Sinope => "Sinope", + DynOrigin::Lysithea => "Lysithea", + DynOrigin::Carme => "Carme", + DynOrigin::Ananke => "Ananke", + DynOrigin::Leda => "Leda", + DynOrigin::Thebe => "Thebe", + DynOrigin::Adrastea => "Adrastea", + DynOrigin::Metis => "Metis", + DynOrigin::Callirrhoe => "Callirrhoe", + DynOrigin::Themisto => "Themisto", + DynOrigin::Magaclite => "Magaclite", + DynOrigin::Taygete => "Taygete", + DynOrigin::Chaldene => "Chaldene", + DynOrigin::Harpalyke => "Harpalyke", + DynOrigin::Kalyke => "Kalyke", + DynOrigin::Iocaste => "Iocaste", + DynOrigin::Erinome => "Erinome", + DynOrigin::Isonoe => "Isonoe", + DynOrigin::Praxidike => "Praxidike", + DynOrigin::Autonoe => "Autonoe", + DynOrigin::Thyone => "Thyone", + DynOrigin::Hermippe => "Hermippe", + DynOrigin::Aitne => "Aitne", + DynOrigin::Eurydome => "Eurydome", + DynOrigin::Euanthe => "Euanthe", + DynOrigin::Euporie => "Euporie", + DynOrigin::Orthosie => "Orthosie", + DynOrigin::Sponde => "Sponde", + DynOrigin::Kale => "Kale", + DynOrigin::Pasithee => "Pasithee", + DynOrigin::Hegemone => "Hegemone", + DynOrigin::Mneme => "Mneme", + DynOrigin::Aoede => "Aoede", + DynOrigin::Thelxinoe => "Thelxinoe", + DynOrigin::Arche => "Arche", + DynOrigin::Kallichore => "Kallichore", + DynOrigin::Helike => "Helike", + DynOrigin::Carpo => "Carpo", + DynOrigin::Eukelade => "Eukelade", + DynOrigin::Cyllene => "Cyllene", + DynOrigin::Kore => "Kore", + DynOrigin::Herse => "Herse", + DynOrigin::Dia => "Dia", + DynOrigin::Mimas => "Mimas", + DynOrigin::Enceladus => "Enceladus", + DynOrigin::Tethys => "Tethys", + DynOrigin::Dione => "Dione", + DynOrigin::Rhea => "Rhea", + DynOrigin::Titan => "Titan", + DynOrigin::Hyperion => "Hyperion", + DynOrigin::Iapetus => "Iapetus", + DynOrigin::Phoebe => "Phoebe", + DynOrigin::Janus => "Janus", + DynOrigin::Epimetheus => "Epimetheus", + DynOrigin::Helene => "Helene", + DynOrigin::Telesto => "Telesto", + DynOrigin::Calypso => "Calypso", + DynOrigin::Atlas => "Atlas", + DynOrigin::Prometheus => "Prometheus", + DynOrigin::Pandora => "Pandora", + DynOrigin::Pan => "Pan", + DynOrigin::Ymir => "Ymir", + DynOrigin::Paaliaq => "Paaliaq", + DynOrigin::Tarvos => "Tarvos", + DynOrigin::Ijiraq => "Ijiraq", + DynOrigin::Suttungr => "Suttungr", + DynOrigin::Kiviuq => "Kiviuq", + DynOrigin::Mundilfari => "Mundilfari", + DynOrigin::Albiorix => "Albiorix", + DynOrigin::Skathi => "Skathi", + DynOrigin::Erriapus => "Erriapus", + DynOrigin::Siarnaq => "Siarnaq", + DynOrigin::Thrymr => "Thrymr", + DynOrigin::Narvi => "Narvi", + DynOrigin::Methone => "Methone", + DynOrigin::Pallene => "Pallene", + DynOrigin::Polydeuces => "Polydeuces", + DynOrigin::Daphnis => "Daphnis", + DynOrigin::Aegir => "Aegir", + DynOrigin::Bebhionn => "Bebhionn", + DynOrigin::Bergelmir => "Bergelmir", + DynOrigin::Bestla => "Bestla", + DynOrigin::Farbauti => "Farbauti", + DynOrigin::Fenrir => "Fenrir", + DynOrigin::Fornjot => "Fornjot", + DynOrigin::Hati => "Hati", + DynOrigin::Hyrrokkin => "Hyrrokkin", + DynOrigin::Kari => "Kari", + DynOrigin::Loge => "Loge", + DynOrigin::Skoll => "Skoll", + DynOrigin::Surtur => "Surtur", + DynOrigin::Anthe => "Anthe", + DynOrigin::Jarnsaxa => "Jarnsaxa", + DynOrigin::Greip => "Greip", + DynOrigin::Tarqeq => "Tarqeq", + DynOrigin::Aegaeon => "Aegaeon", + DynOrigin::Ariel => "Ariel", + DynOrigin::Umbriel => "Umbriel", + DynOrigin::Titania => "Titania", + DynOrigin::Oberon => "Oberon", + DynOrigin::Miranda => "Miranda", + DynOrigin::Cordelia => "Cordelia", + DynOrigin::Ophelia => "Ophelia", + DynOrigin::Bianca => "Bianca", + DynOrigin::Cressida => "Cressida", + DynOrigin::Desdemona => "Desdemona", + DynOrigin::Juliet => "Juliet", + DynOrigin::Portia => "Portia", + DynOrigin::Rosalind => "Rosalind", + DynOrigin::Belinda => "Belinda", + DynOrigin::Puck => "Puck", + DynOrigin::Caliban => "Caliban", + DynOrigin::Sycorax => "Sycorax", + DynOrigin::Prospero => "Prospero", + DynOrigin::Setebos => "Setebos", + DynOrigin::Stephano => "Stephano", + DynOrigin::Trinculo => "Trinculo", + DynOrigin::Francisco => "Francisco", + DynOrigin::Margaret => "Margaret", + DynOrigin::Ferdinand => "Ferdinand", + DynOrigin::Perdita => "Perdita", + DynOrigin::Mab => "Mab", + DynOrigin::Cupid => "Cupid", + DynOrigin::Triton => "Triton", + DynOrigin::Nereid => "Nereid", + DynOrigin::Naiad => "Naiad", + DynOrigin::Thalassa => "Thalassa", + DynOrigin::Despina => "Despina", + DynOrigin::Galatea => "Galatea", + DynOrigin::Larissa => "Larissa", + DynOrigin::Proteus => "Proteus", + DynOrigin::Halimede => "Halimede", + DynOrigin::Psamathe => "Psamathe", + DynOrigin::Sao => "Sao", + DynOrigin::Laomedeia => "Laomedeia", + DynOrigin::Neso => "Neso", + DynOrigin::Charon => "Charon", + DynOrigin::Nix => "Nix", + DynOrigin::Hydra => "Hydra", + DynOrigin::Kerberos => "Kerberos", + DynOrigin::Styx => "Styx", + + // Minor bodies. + DynOrigin::Gaspra => "Gaspra", + DynOrigin::Ida => "Ida", + DynOrigin::Dactyl => "Dactyl", + DynOrigin::Ceres => "Ceres", + DynOrigin::Pallas => "Pallas", + DynOrigin::Vesta => "Vesta", + DynOrigin::Psyche => "Psyche", + DynOrigin::Lutetia => "Lutetia", + DynOrigin::Kleopatra => "Kleopatra", + DynOrigin::Eros => "Eros", + DynOrigin::Davida => "Davida", + DynOrigin::Mathilde => "Mathilde", + DynOrigin::Steins => "Steins", + DynOrigin::Braille => "Braille", + DynOrigin::WilsonHarrington => "Wilson-Harrington", + DynOrigin::Toutatis => "Toutatis", + DynOrigin::Itokawa => "Itokawa", + DynOrigin::Bennu => "Bennu", + } + } +} + +impl Display for DynOrigin { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} + +impl TryFrom for DynOrigin { + type Error = UnknownOriginId; + + fn try_from(value: i32) -> Result { + DynOrigin::from_i32(value).ok_or(UnknownOriginId(value)) + } +} + +impl TryFrom for DynOrigin { + type Error = UnknownOriginId; + + fn try_from(id: NaifId) -> Result { + DynOrigin::try_from(id.0) + } +} + +impl FromStr for DynOrigin { + type Err = UnknownOriginName; + + fn from_str(s: &str) -> Result { + match s { + "sun" | "Sun" => Ok(DynOrigin::Sun), + "ssb" | "SSB" | "solar system barycenter" | "Solar System Barycenter" => { + Ok(DynOrigin::SolarSystemBarycenter) + } + "mercury barycenter" | "Mercury Barycenter" => Ok(DynOrigin::MercuryBarycenter), + "venus barycenter" | "Venus Barycenter" => Ok(DynOrigin::VenusBarycenter), + "earth barycenter" | "Earth Barycenter" => Ok(DynOrigin::EarthBarycenter), + "mars barycenter" | "Mars Barycenter" => Ok(DynOrigin::MarsBarycenter), + "jupiter barycenter" | "Jupiter Barycenter" => Ok(DynOrigin::JupiterBarycenter), + "saturn barycenter" | "Saturn Barycenter" => Ok(DynOrigin::SaturnBarycenter), + "uranus barycenter" | "Uranus Barycenter" => Ok(DynOrigin::UranusBarycenter), + "neptune barycenter" | "Neptune Barycenter" => Ok(DynOrigin::NeptuneBarycenter), + "pluto barycenter" | "Pluto Barycenter" => Ok(DynOrigin::PlutoBarycenter), + "mercury" | "Mercury" => Ok(DynOrigin::Mercury), + "venus" | "Venus" => Ok(DynOrigin::Venus), + "earth" | "Earth" => Ok(DynOrigin::Earth), + "mars" | "Mars" => Ok(DynOrigin::Mars), + "jupiter" | "Jupiter" => Ok(DynOrigin::Jupiter), + "saturn" | "Saturn" => Ok(DynOrigin::Saturn), + "uranus" | "Uranus" => Ok(DynOrigin::Uranus), + "neptune" | "Neptune" => Ok(DynOrigin::Neptune), + "pluto" | "Pluto" => Ok(DynOrigin::Pluto), + "moon" | "Moon" | "luna" | "Luna" => Ok(DynOrigin::Moon), + "phobos" | "Phobos" => Ok(DynOrigin::Phobos), + "deimos" | "Deimos" => Ok(DynOrigin::Deimos), + "io" | "Io" => Ok(DynOrigin::Io), + "europa" | "Europa" => Ok(DynOrigin::Europa), + "ganymede" | "Ganymede" => Ok(DynOrigin::Ganymede), + "callisto" | "Callisto" => Ok(DynOrigin::Callisto), + "amalthea" | "Amalthea" => Ok(DynOrigin::Amalthea), + "himalia" | "Himalia" => Ok(DynOrigin::Himalia), + "elara" | "Elara" => Ok(DynOrigin::Elara), + "pasiphae" | "Pasiphae" => Ok(DynOrigin::Pasiphae), + "sinope" | "Sinope" => Ok(DynOrigin::Sinope), + "lysithea" | "Lysithea" => Ok(DynOrigin::Lysithea), + "carme" | "Carme" => Ok(DynOrigin::Carme), + "ananke" | "Ananke" => Ok(DynOrigin::Ananke), + "leda" | "Leda" => Ok(DynOrigin::Leda), + "thebe" | "Thebe" => Ok(DynOrigin::Thebe), + "adrastea" | "Adrastea" => Ok(DynOrigin::Adrastea), + "metis" | "Metis" => Ok(DynOrigin::Metis), + "callirrhoe" | "Callirrhoe" => Ok(DynOrigin::Callirrhoe), + "themisto" | "Themisto" => Ok(DynOrigin::Themisto), + "magaclite" | "Magaclite" => Ok(DynOrigin::Magaclite), + "taygete" | "Taygete" => Ok(DynOrigin::Taygete), + "chaldene" | "Chaldene" => Ok(DynOrigin::Chaldene), + "harpalyke" | "Harpalyke" => Ok(DynOrigin::Harpalyke), + "kalyke" | "Kalyke" => Ok(DynOrigin::Kalyke), + "iocaste" | "Iocaste" => Ok(DynOrigin::Iocaste), + "erinome" | "Erinome" => Ok(DynOrigin::Erinome), + "isonoe" | "Isonoe" => Ok(DynOrigin::Isonoe), + "praxidike" | "Praxidike" => Ok(DynOrigin::Praxidike), + "autonoe" | "Autonoe" => Ok(DynOrigin::Autonoe), + "thyone" | "Thyone" => Ok(DynOrigin::Thyone), + "hermippe" | "Hermippe" => Ok(DynOrigin::Hermippe), + "aitne" | "Aitne" => Ok(DynOrigin::Aitne), + "eurydome" | "Eurydome" => Ok(DynOrigin::Eurydome), + "euanthe" | "Euanthe" => Ok(DynOrigin::Euanthe), + "euporie" | "Euporie" => Ok(DynOrigin::Euporie), + "orthosie" | "Orthosie" => Ok(DynOrigin::Orthosie), + "sponde" | "Sponde" => Ok(DynOrigin::Sponde), + "kale" | "Kale" => Ok(DynOrigin::Kale), + "pasithee" | "Pasithee" => Ok(DynOrigin::Pasithee), + "hegemone" | "Hegemone" => Ok(DynOrigin::Hegemone), + "mneme" | "Mneme" => Ok(DynOrigin::Mneme), + "aoede" | "Aoede" => Ok(DynOrigin::Aoede), + "thelxinoe" | "Thelxinoe" => Ok(DynOrigin::Thelxinoe), + "arche" | "Arche" => Ok(DynOrigin::Arche), + "kallichore" | "Kallichore" => Ok(DynOrigin::Kallichore), + "helike" | "Helike" => Ok(DynOrigin::Helike), + "carpo" | "Carpo" => Ok(DynOrigin::Carpo), + "eukelade" | "Eukelade" => Ok(DynOrigin::Eukelade), + "cyllene" | "Cyllene" => Ok(DynOrigin::Cyllene), + "kore" | "Kore" => Ok(DynOrigin::Kore), + "herse" | "Herse" => Ok(DynOrigin::Herse), + "dia" | "Dia" => Ok(DynOrigin::Dia), + "mimas" | "Mimas" => Ok(DynOrigin::Mimas), + "enceladus" | "Enceladus" => Ok(DynOrigin::Enceladus), + "tethys" | "Tethys" => Ok(DynOrigin::Tethys), + "dione" | "Dione" => Ok(DynOrigin::Dione), + "rhea" | "Rhea" => Ok(DynOrigin::Rhea), + "titan" | "Titan" => Ok(DynOrigin::Titan), + "hyperion" | "Hyperion" => Ok(DynOrigin::Hyperion), + "iapetus" | "Iapetus" => Ok(DynOrigin::Iapetus), + "phoebe" | "Phoebe" => Ok(DynOrigin::Phoebe), + "janus" | "Janus" => Ok(DynOrigin::Janus), + "epimetheus" | "Epimetheus" => Ok(DynOrigin::Epimetheus), + "helene" | "Helene" => Ok(DynOrigin::Helene), + "telesto" | "Telesto" => Ok(DynOrigin::Telesto), + "calypso" | "Calypso" => Ok(DynOrigin::Calypso), + "atlas" | "Atlas" => Ok(DynOrigin::Atlas), + "prometheus" | "Prometheus" => Ok(DynOrigin::Prometheus), + "pandora" | "Pandora" => Ok(DynOrigin::Pandora), + "pan" | "Pan" => Ok(DynOrigin::Pan), + "ymir" | "Ymir" => Ok(DynOrigin::Ymir), + "paaliaq" | "Paaliaq" => Ok(DynOrigin::Paaliaq), + "tarvos" | "Tarvos" => Ok(DynOrigin::Tarvos), + "ijiraq" | "Ijiraq" => Ok(DynOrigin::Ijiraq), + "suttungr" | "Suttungr" => Ok(DynOrigin::Suttungr), + "kiviuq" | "Kiviuq" => Ok(DynOrigin::Kiviuq), + "mundilfari" | "Mundilfari" => Ok(DynOrigin::Mundilfari), + "albiorix" | "Albiorix" => Ok(DynOrigin::Albiorix), + "skathi" | "Skathi" => Ok(DynOrigin::Skathi), + "erriapus" | "Erriapus" => Ok(DynOrigin::Erriapus), + "siarnaq" | "Siarnaq" => Ok(DynOrigin::Siarnaq), + "thrymr" | "Thrymr" => Ok(DynOrigin::Thrymr), + "narvi" | "Narvi" => Ok(DynOrigin::Narvi), + "methone" | "Methone" => Ok(DynOrigin::Methone), + "pallene" | "Pallene" => Ok(DynOrigin::Pallene), + "polydeuces" | "Polydeuces" => Ok(DynOrigin::Polydeuces), + "daphnis" | "Daphnis" => Ok(DynOrigin::Daphnis), + "aegir" | "Aegir" => Ok(DynOrigin::Aegir), + "bebhionn" | "Bebhionn" => Ok(DynOrigin::Bebhionn), + "bergelmir" | "Bergelmir" => Ok(DynOrigin::Bergelmir), + "bestla" | "Bestla" => Ok(DynOrigin::Bestla), + "farbauti" | "Farbauti" => Ok(DynOrigin::Farbauti), + "fenrir" | "Fenrir" => Ok(DynOrigin::Fenrir), + "fornjot" | "Fornjot" => Ok(DynOrigin::Fornjot), + "hati" | "Hati" => Ok(DynOrigin::Hati), + "hyrrokkin" | "Hyrrokkin" => Ok(DynOrigin::Hyrrokkin), + "kari" | "Kari" => Ok(DynOrigin::Kari), + "loge" | "Loge" => Ok(DynOrigin::Loge), + "skoll" | "Skoll" => Ok(DynOrigin::Skoll), + "surtur" | "Surtur" => Ok(DynOrigin::Surtur), + "anthe" | "Anthe" => Ok(DynOrigin::Anthe), + "jarnsaxa" | "Jarnsaxa" => Ok(DynOrigin::Jarnsaxa), + "greip" | "Greip" => Ok(DynOrigin::Greip), + "tarqeq" | "Tarqeq" => Ok(DynOrigin::Tarqeq), + "aegaeon" | "Aegaeon" => Ok(DynOrigin::Aegaeon), + "ariel" | "Ariel" => Ok(DynOrigin::Ariel), + "umbriel" | "Umbriel" => Ok(DynOrigin::Umbriel), + "titania" | "Titania" => Ok(DynOrigin::Titania), + "oberon" | "Oberon" => Ok(DynOrigin::Oberon), + "miranda" | "Miranda" => Ok(DynOrigin::Miranda), + "cordelia" | "Cordelia" => Ok(DynOrigin::Cordelia), + "ophelia" | "Ophelia" => Ok(DynOrigin::Ophelia), + "bianca" | "Bianca" => Ok(DynOrigin::Bianca), + "cressida" | "Cressida" => Ok(DynOrigin::Cressida), + "desdemona" | "Desdemona" => Ok(DynOrigin::Desdemona), + "juliet" | "Juliet" => Ok(DynOrigin::Juliet), + "portia" | "Portia" => Ok(DynOrigin::Portia), + "rosalind" | "Rosalind" => Ok(DynOrigin::Rosalind), + "belinda" | "Belinda" => Ok(DynOrigin::Belinda), + "puck" | "Puck" => Ok(DynOrigin::Puck), + "caliban" | "Caliban" => Ok(DynOrigin::Caliban), + "sycorax" | "Sycorax" => Ok(DynOrigin::Sycorax), + "prospero" | "Prospero" => Ok(DynOrigin::Prospero), + "setebos" | "Setebos" => Ok(DynOrigin::Setebos), + "stephano" | "Stephano" => Ok(DynOrigin::Stephano), + "trinculo" | "Trinculo" => Ok(DynOrigin::Trinculo), + "francisco" | "Francisco" => Ok(DynOrigin::Francisco), + "margaret" | "Margaret" => Ok(DynOrigin::Margaret), + "ferdinand" | "Ferdinand" => Ok(DynOrigin::Ferdinand), + "perdita" | "Perdita" => Ok(DynOrigin::Perdita), + "mab" | "Mab" => Ok(DynOrigin::Mab), + "cupid" | "Cupid" => Ok(DynOrigin::Cupid), + "triton" | "Triton" => Ok(DynOrigin::Triton), + "nereid" | "Nereid" => Ok(DynOrigin::Nereid), + "naiad" | "Naiad" => Ok(DynOrigin::Naiad), + "thalassa" | "Thalassa" => Ok(DynOrigin::Thalassa), + "despina" | "Despina" => Ok(DynOrigin::Despina), + "galatea" | "Galatea" => Ok(DynOrigin::Galatea), + "larissa" | "Larissa" => Ok(DynOrigin::Larissa), + "proteus" | "Proteus" => Ok(DynOrigin::Proteus), + "halimede" | "Halimede" => Ok(DynOrigin::Halimede), + "psamathe" | "Psamathe" => Ok(DynOrigin::Psamathe), + "sao" | "Sao" => Ok(DynOrigin::Sao), + "laomedeia" | "Laomedeia" => Ok(DynOrigin::Laomedeia), + "neso" | "Neso" => Ok(DynOrigin::Neso), + "charon" | "Charon" => Ok(DynOrigin::Charon), + "nix" | "Nix" => Ok(DynOrigin::Nix), + "hydra" | "Hydra" => Ok(DynOrigin::Hydra), + "kerberos" | "Kerberos" => Ok(DynOrigin::Kerberos), + "styx" | "Styx" => Ok(DynOrigin::Styx), + + // Minor bodies. + "gaspra" | "Gaspra" => Ok(DynOrigin::Gaspra), + "ida" | "Ida" => Ok(DynOrigin::Ida), + "dactyl" | "Dactyl" => Ok(DynOrigin::Dactyl), + "ceres" | "Ceres" => Ok(DynOrigin::Ceres), + "pallas" | "Pallas" => Ok(DynOrigin::Pallas), + "vesta" | "Vesta" => Ok(DynOrigin::Vesta), + "psyche" | "Psyche" => Ok(DynOrigin::Psyche), + "lutetia" | "Lutetia" => Ok(DynOrigin::Lutetia), + "kleopatra" | "Kleopatra" => Ok(DynOrigin::Kleopatra), + "eros" | "Eros" => Ok(DynOrigin::Eros), + "davida" | "Davida" => Ok(DynOrigin::Davida), + "mathilde" | "Mathilde" => Ok(DynOrigin::Mathilde), + "steins" | "Steins" => Ok(DynOrigin::Steins), + "braille" | "Braille" => Ok(DynOrigin::Braille), + "wilson-harrington" | "Wilson-Harrington" | "wilson" | "Wilson" => { + Ok(DynOrigin::WilsonHarrington) + } + "toutatis" | "Toutatis" => Ok(DynOrigin::Toutatis), + "itokawa" | "Itokawa" => Ok(DynOrigin::Itokawa), + "bennu" | "Bennu" => Ok(DynOrigin::Bennu), + + _ => Err(UnknownOriginName(s.to_owned())), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use rstest::rstest; + + #[rstest] + #[case(DynOrigin::Sun)] + #[case(DynOrigin::Mercury)] + #[case(DynOrigin::Venus)] + #[case(DynOrigin::Earth)] + #[case(DynOrigin::Mars)] + #[case(DynOrigin::Jupiter)] + #[case(DynOrigin::Saturn)] + #[case(DynOrigin::Uranus)] + #[case(DynOrigin::Neptune)] + #[case(DynOrigin::Pluto)] + #[case(DynOrigin::SolarSystemBarycenter)] + #[case(DynOrigin::MercuryBarycenter)] + #[case(DynOrigin::VenusBarycenter)] + #[case(DynOrigin::EarthBarycenter)] + #[case(DynOrigin::MarsBarycenter)] + #[case(DynOrigin::JupiterBarycenter)] + #[case(DynOrigin::SaturnBarycenter)] + #[case(DynOrigin::UranusBarycenter)] + #[case(DynOrigin::NeptuneBarycenter)] + #[case(DynOrigin::PlutoBarycenter)] + #[case(DynOrigin::Moon)] + #[case(DynOrigin::Phobos)] + #[case(DynOrigin::Deimos)] + #[case(DynOrigin::Io)] + #[case(DynOrigin::Europa)] + #[case(DynOrigin::Ganymede)] + #[case(DynOrigin::Callisto)] + #[case(DynOrigin::Amalthea)] + #[case(DynOrigin::Himalia)] + #[case(DynOrigin::Elara)] + #[case(DynOrigin::Pasiphae)] + #[case(DynOrigin::Sinope)] + #[case(DynOrigin::Lysithea)] + #[case(DynOrigin::Carme)] + #[case(DynOrigin::Ananke)] + #[case(DynOrigin::Leda)] + #[case(DynOrigin::Thebe)] + #[case(DynOrigin::Adrastea)] + #[case(DynOrigin::Metis)] + #[case(DynOrigin::Callirrhoe)] + #[case(DynOrigin::Themisto)] + #[case(DynOrigin::Magaclite)] + #[case(DynOrigin::Taygete)] + #[case(DynOrigin::Chaldene)] + #[case(DynOrigin::Harpalyke)] + #[case(DynOrigin::Kalyke)] + #[case(DynOrigin::Iocaste)] + #[case(DynOrigin::Erinome)] + #[case(DynOrigin::Isonoe)] + #[case(DynOrigin::Praxidike)] + #[case(DynOrigin::Autonoe)] + #[case(DynOrigin::Thyone)] + #[case(DynOrigin::Hermippe)] + #[case(DynOrigin::Aitne)] + #[case(DynOrigin::Eurydome)] + #[case(DynOrigin::Euanthe)] + #[case(DynOrigin::Euporie)] + #[case(DynOrigin::Orthosie)] + #[case(DynOrigin::Sponde)] + #[case(DynOrigin::Kale)] + #[case(DynOrigin::Pasithee)] + #[case(DynOrigin::Hegemone)] + #[case(DynOrigin::Mneme)] + #[case(DynOrigin::Aoede)] + #[case(DynOrigin::Thelxinoe)] + #[case(DynOrigin::Arche)] + #[case(DynOrigin::Kallichore)] + #[case(DynOrigin::Helike)] + #[case(DynOrigin::Carpo)] + #[case(DynOrigin::Eukelade)] + #[case(DynOrigin::Cyllene)] + #[case(DynOrigin::Kore)] + #[case(DynOrigin::Herse)] + #[case(DynOrigin::Dia)] + #[case(DynOrigin::Mimas)] + #[case(DynOrigin::Enceladus)] + #[case(DynOrigin::Tethys)] + #[case(DynOrigin::Dione)] + #[case(DynOrigin::Rhea)] + #[case(DynOrigin::Titan)] + #[case(DynOrigin::Hyperion)] + #[case(DynOrigin::Iapetus)] + #[case(DynOrigin::Phoebe)] + #[case(DynOrigin::Janus)] + #[case(DynOrigin::Epimetheus)] + #[case(DynOrigin::Helene)] + #[case(DynOrigin::Telesto)] + #[case(DynOrigin::Calypso)] + #[case(DynOrigin::Atlas)] + #[case(DynOrigin::Prometheus)] + #[case(DynOrigin::Pandora)] + #[case(DynOrigin::Pan)] + #[case(DynOrigin::Ymir)] + #[case(DynOrigin::Paaliaq)] + #[case(DynOrigin::Tarvos)] + #[case(DynOrigin::Ijiraq)] + #[case(DynOrigin::Suttungr)] + #[case(DynOrigin::Kiviuq)] + #[case(DynOrigin::Mundilfari)] + #[case(DynOrigin::Albiorix)] + #[case(DynOrigin::Skathi)] + #[case(DynOrigin::Erriapus)] + #[case(DynOrigin::Siarnaq)] + #[case(DynOrigin::Thrymr)] + #[case(DynOrigin::Narvi)] + #[case(DynOrigin::Methone)] + #[case(DynOrigin::Pallene)] + #[case(DynOrigin::Polydeuces)] + #[case(DynOrigin::Daphnis)] + #[case(DynOrigin::Aegir)] + #[case(DynOrigin::Bebhionn)] + #[case(DynOrigin::Bergelmir)] + #[case(DynOrigin::Bestla)] + #[case(DynOrigin::Farbauti)] + #[case(DynOrigin::Fenrir)] + #[case(DynOrigin::Fornjot)] + #[case(DynOrigin::Hati)] + #[case(DynOrigin::Hyrrokkin)] + #[case(DynOrigin::Kari)] + #[case(DynOrigin::Loge)] + #[case(DynOrigin::Skoll)] + #[case(DynOrigin::Surtur)] + #[case(DynOrigin::Anthe)] + #[case(DynOrigin::Jarnsaxa)] + #[case(DynOrigin::Greip)] + #[case(DynOrigin::Tarqeq)] + #[case(DynOrigin::Aegaeon)] + #[case(DynOrigin::Ariel)] + #[case(DynOrigin::Umbriel)] + #[case(DynOrigin::Titania)] + #[case(DynOrigin::Oberon)] + #[case(DynOrigin::Miranda)] + #[case(DynOrigin::Cordelia)] + #[case(DynOrigin::Ophelia)] + #[case(DynOrigin::Bianca)] + #[case(DynOrigin::Cressida)] + #[case(DynOrigin::Desdemona)] + #[case(DynOrigin::Juliet)] + #[case(DynOrigin::Portia)] + #[case(DynOrigin::Rosalind)] + #[case(DynOrigin::Belinda)] + #[case(DynOrigin::Puck)] + #[case(DynOrigin::Caliban)] + #[case(DynOrigin::Sycorax)] + #[case(DynOrigin::Prospero)] + #[case(DynOrigin::Setebos)] + #[case(DynOrigin::Stephano)] + #[case(DynOrigin::Trinculo)] + #[case(DynOrigin::Francisco)] + #[case(DynOrigin::Margaret)] + #[case(DynOrigin::Ferdinand)] + #[case(DynOrigin::Perdita)] + #[case(DynOrigin::Mab)] + #[case(DynOrigin::Cupid)] + #[case(DynOrigin::Triton)] + #[case(DynOrigin::Nereid)] + #[case(DynOrigin::Naiad)] + #[case(DynOrigin::Thalassa)] + #[case(DynOrigin::Despina)] + #[case(DynOrigin::Galatea)] + #[case(DynOrigin::Larissa)] + #[case(DynOrigin::Proteus)] + #[case(DynOrigin::Halimede)] + #[case(DynOrigin::Psamathe)] + #[case(DynOrigin::Sao)] + #[case(DynOrigin::Laomedeia)] + #[case(DynOrigin::Neso)] + #[case(DynOrigin::Charon)] + #[case(DynOrigin::Nix)] + #[case(DynOrigin::Hydra)] + #[case(DynOrigin::Kerberos)] + #[case(DynOrigin::Styx)] + #[case(DynOrigin::Gaspra)] + #[case(DynOrigin::Ida)] + #[case(DynOrigin::Dactyl)] + #[case(DynOrigin::Ceres)] + #[case(DynOrigin::Pallas)] + #[case(DynOrigin::Vesta)] + #[case(DynOrigin::Psyche)] + #[case(DynOrigin::Lutetia)] + #[case(DynOrigin::Kleopatra)] + #[case(DynOrigin::Eros)] + #[case(DynOrigin::Davida)] + #[case(DynOrigin::Mathilde)] + #[case(DynOrigin::Steins)] + #[case(DynOrigin::Braille)] + #[case(DynOrigin::WilsonHarrington)] + #[case(DynOrigin::Toutatis)] + #[case(DynOrigin::Itokawa)] + #[case(DynOrigin::Bennu)] + fn test_dyn_origin(#[case] exp: DynOrigin) { + let act = DynOrigin::try_from(exp.to_i32().unwrap()).unwrap(); + assert_eq!(act, exp); + let act = DynOrigin::try_from(exp.id()).unwrap(); + assert_eq!(act, exp); + let act = DynOrigin::from_str(exp.to_string().as_str()).unwrap(); + assert_eq!(act, exp); + } + + #[test] + fn test_dyn_origin_unknown_name() { + assert_eq!( + DynOrigin::from_str("Rupert"), + Err(UnknownOriginName("Rupert".to_string())) + ); + } + + #[test] + fn test_dyn_origin_unknown_id() { + assert_eq!(DynOrigin::try_from(666), Err(UnknownOriginId(666))) + } +} diff --git a/crates/lox-bodies/src/errors.rs b/crates/lox-bodies/src/errors.rs deleted file mode 100644 index 67503606..00000000 --- a/crates/lox-bodies/src/errors.rs +++ /dev/null @@ -1,15 +0,0 @@ -/* - * Copyright (c) 2023-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/. - */ - -use thiserror::Error; - -#[derive(Error, Debug, PartialEq)] -pub enum LoxBodiesError { - #[error("unknown body `{0}`")] - UnknownBody(String), -} diff --git a/crates/lox-bodies/src/fundamental/simon1994.rs b/crates/lox-bodies/src/fundamental/simon1994.rs index 23d826d7..bf2e7851 100644 --- a/crates/lox-bodies/src/fundamental/simon1994.rs +++ b/crates/lox-bodies/src/fundamental/simon1994.rs @@ -64,7 +64,7 @@ mod tests { // This is somewhat loose, being based on observations of how closely our implementations // match ERFA outputs rather than any target tolerance. // See https://github.com/lox-space/lox/pull/23#discussion_r1398485509 - const TOLERANCE: f64 = 1e-12; + const TOLERANCE: f64 = 1e-10; // Test cases for t. const T_ZERO: JulianCenturies = 0.0; diff --git a/crates/lox-bodies/src/generated.rs b/crates/lox-bodies/src/generated.rs index 11cb2ae9..521adbd0 100644 --- a/crates/lox-bodies/src/generated.rs +++ b/crates/lox-bodies/src/generated.rs @@ -1,18 +1,9729 @@ /* - * Copyright (c) 2023-2024. Helge Eichhorn and the LOX contributors + * 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/. */ -//! generated holds trait implementations that have been generated by `lox-gen`, separating -//! generated code from manual implementations. -//! -//! Artifacts in its submodules are intended to be transparently re-exported. +// Auto-generated by `lox-gen`. Do not edit! -pub mod barycenters; -pub mod minor; -pub mod planets; -pub mod satellites; -pub mod sun; +use crate::DynOrigin; +use crate::Elements; +use crate::MaybeMeanRadius; +use crate::MaybePointMass; +use crate::MaybeSpheroid; +use crate::MaybeTriaxialEllipsoid; +use crate::MeanRadius; +use crate::NaifId; +use crate::NutationPrecessionCoefficients; +use crate::Origin; +use crate::PointMass; +use crate::Radii; +use crate::RotationalElement; +use crate::RotationalElementType; +use crate::RotationalElements; +use crate::Spheroid; +use crate::TriaxialEllipsoid; +use crate::TryRotationalElements; +use crate::UndefinedRotationalElementsError; +use std::fmt::Display; +use std::fmt::Formatter; +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Sun; +impl Origin for Sun { + fn id(&self) -> NaifId { + NaifId(10i32) + } + fn name(&self) -> &'static str { + "Sun" + } +} +impl Display for Sun { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Sun { + fn gravitational_parameter(&self) -> f64 { + 132712440041.27942f64 + } +} +impl TriaxialEllipsoid for Sun { + fn radii(&self) -> Radii { + (695700f64, 695700f64, 695700f64) + } +} +impl Spheroid for Sun {} +const RIGHT_ASCENSION_SUN: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.993910588731375f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const DECLINATION_SUN: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.1147417932487782f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const ROTATION_SUN: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 1.4691483511587469f64, + c1: 0.24756448241988369f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Sun { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_SUN.angle::<0usize>(None, t), + DECLINATION_SUN.angle::<0usize>(None, t), + ROTATION_SUN.angle::<0usize>(None, t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_SUN.angle_dot::<0usize>(None, t), + DECLINATION_SUN.angle_dot::<0usize>(None, t), + ROTATION_SUN.angle_dot::<0usize>(None, t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Mercury; +impl Origin for Mercury { + fn id(&self) -> NaifId { + NaifId(199i32) + } + fn name(&self) -> &'static str { + "Mercury" + } +} +impl Display for Mercury { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Mercury { + fn gravitational_parameter(&self) -> f64 { + 22031.868551400003f64 + } +} +impl MeanRadius for Mercury { + fn mean_radius(&self) -> f64 { + 2439.4f64 + } +} +impl TriaxialEllipsoid for Mercury { + fn radii(&self) -> Radii { + (2440.53f64, 2440.53f64, 2438.26f64) + } +} +impl Spheroid for Mercury {} +const RIGHT_ASCENSION_MERCURY: RotationalElement<5usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.904554967017021f64, + c1: -0.0005724679946541401f64, + c2: 0f64, + c: Some([0f64, 0f64, 0f64, 0f64, 0f64]), +}; +const DECLINATION_MERCURY: RotationalElement<5usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.0719026867585775f64, + c1: -0.00008552113334772214f64, + c2: 0f64, + c: Some([0f64, 0f64, 0f64, 0f64, 0f64]), +}; +const ROTATION_MERCURY: RotationalElement<5usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 5.752584270622286f64, + c1: 0.10713722462923113f64, + c2: 0f64, + c: Some([ + 0.0001862714861495712f64, + -0.000019601618296223117f64, + -0.00000192684349420174f64, + -0.00000044313909708136026f64, + -0.00000009965830028887623f64, + ]), +}; +impl RotationalElements for Mercury { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_MERCURY.angle::<5usize>(Some(&NUTATION_PRECESSION_MERCURY), t), + DECLINATION_MERCURY.angle::<5usize>(Some(&NUTATION_PRECESSION_MERCURY), t), + ROTATION_MERCURY.angle::<5usize>(Some(&NUTATION_PRECESSION_MERCURY), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_MERCURY.angle_dot::<5usize>(Some(&NUTATION_PRECESSION_MERCURY), t), + DECLINATION_MERCURY.angle_dot::<5usize>(Some(&NUTATION_PRECESSION_MERCURY), t), + ROTATION_MERCURY.angle_dot::<5usize>(Some(&NUTATION_PRECESSION_MERCURY), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Venus; +impl Origin for Venus { + fn id(&self) -> NaifId { + NaifId(299i32) + } + fn name(&self) -> &'static str { + "Venus" + } +} +impl Display for Venus { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Venus { + fn gravitational_parameter(&self) -> f64 { + 324858.592f64 + } +} +impl MeanRadius for Venus { + fn mean_radius(&self) -> f64 { + 6051.8f64 + } +} +impl TriaxialEllipsoid for Venus { + fn radii(&self) -> Radii { + (6051.8f64, 6051.8f64, 6051.8f64) + } +} +impl Spheroid for Venus {} +const RIGHT_ASCENSION_VENUS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.760560067739733f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const DECLINATION_VENUS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.1721631256393916f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const ROTATION_VENUS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 2.7960174616949156f64, + c1: -0.025854762996317376f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Venus { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_VENUS.angle::<0usize>(None, t), + DECLINATION_VENUS.angle::<0usize>(None, t), + ROTATION_VENUS.angle::<0usize>(None, t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_VENUS.angle_dot::<0usize>(None, t), + DECLINATION_VENUS.angle_dot::<0usize>(None, t), + ROTATION_VENUS.angle_dot::<0usize>(None, t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Earth; +impl Origin for Earth { + fn id(&self) -> NaifId { + NaifId(399i32) + } + fn name(&self) -> &'static str { + "Earth" + } +} +impl Display for Earth { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Earth { + fn gravitational_parameter(&self) -> f64 { + 398600.43550702266f64 + } +} +impl MeanRadius for Earth { + fn mean_radius(&self) -> f64 { + 6371.0084f64 + } +} +impl TriaxialEllipsoid for Earth { + fn radii(&self) -> Radii { + (6378.1366f64, 6378.1366f64, 6356.7519f64) + } +} +impl Spheroid for Earth {} +const RIGHT_ASCENSION_EARTH: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0f64, + c1: -0.011187560505283653f64, + c2: 0f64, + c: None, +}; +const DECLINATION_EARTH: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.5707963267948966f64, + c1: -0.009721483933608416f64, + c2: 0f64, + c: None, +}; +const ROTATION_EARTH: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 3.3186912127896577f64, + c1: 6.3003876824396166f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Earth { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_EARTH.angle::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + DECLINATION_EARTH.angle::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + ROTATION_EARTH.angle::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_EARTH.angle_dot::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + DECLINATION_EARTH.angle_dot::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + ROTATION_EARTH.angle_dot::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Mars; +impl Origin for Mars { + fn id(&self) -> NaifId { + NaifId(499i32) + } + fn name(&self) -> &'static str { + "Mars" + } +} +impl Display for Mars { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Mars { + fn gravitational_parameter(&self) -> f64 { + 42828.37362069909f64 + } +} +impl MeanRadius for Mars { + fn mean_radius(&self) -> f64 { + 3389.5f64 + } +} +impl TriaxialEllipsoid for Mars { + fn radii(&self) -> Radii { + (3396.19f64, 3396.19f64, 3376.2f64) + } +} +impl Spheroid for Mars {} +const RIGHT_ASCENSION_MARS: RotationalElement<15usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 5.5373921900749785f64, + c1: -0.001907216743164288f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.000001186823891356144f64, + 0.000004153883619746505f64, + 0.0000009075712110370513f64, + 0.00000015707963267948966f64, + 0.007313924403529878f64, + ]), +}; +const DECLINATION_MARS: RotationalElement<20usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 0.9500266243444937f64, + c1: -0.0010170216810942417f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.000000890117918517108f64, + 0.000002460914245312005f64, + 0.0000005410520681182422f64, + 0.00000008726646259971648f64, + 0.02777297060138025f64, + ]), +}; +const ROTATION_MARS: RotationalElement<26usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 3.0726497570349416f64, + c1: 6.12422041248567f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.000002530727415391778f64, + 0.0000027401669256310974f64, + 0.0000006981317007977319f64, + 0.000000017453292519943295f64, + 0.000000017453292519943295f64, + 0.010202182516192693f64, + ]), +}; +impl RotationalElements for Mars { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_MARS.angle::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + DECLINATION_MARS.angle::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + ROTATION_MARS.angle::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_MARS.angle_dot::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + DECLINATION_MARS.angle_dot::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + ROTATION_MARS.angle_dot::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Jupiter; +impl Origin for Jupiter { + fn id(&self) -> NaifId { + NaifId(599i32) + } + fn name(&self) -> &'static str { + "Jupiter" + } +} +impl Display for Jupiter { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Jupiter { + fn gravitational_parameter(&self) -> f64 { + 126686531.9003704f64 + } +} +impl MeanRadius for Jupiter { + fn mean_radius(&self) -> f64 { + 69911f64 + } +} +impl TriaxialEllipsoid for Jupiter { + fn radii(&self) -> Radii { + (71492f64, 71492f64, 66854f64) + } +} +impl Spheroid for Jupiter {} +const RIGHT_ASCENSION_JUPITER: RotationalElement<15usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.6784701644349695f64, + c1: -0.00011342894808711148f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.0000020420352248333656f64, + 0.000016371188383706813f64, + 0.000024993114888558796f64, + 0.0000005235987755982989f64, + 0.00003752457891787809f64, + ]), +}; +const DECLINATION_JUPITER: RotationalElement<15usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.1256553894213766f64, + c1: 0.00004211479485062318f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.0000008726646259971648f64, + 0.000007051130178057092f64, + 0.000010768681484805013f64, + -0.00000022689280275926283f64, + 0.00001616174887346749f64, + ]), +}; +const ROTATION_JUPITER: RotationalElement<15usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 4.973315703557842f64, + c1: 15.193719457141356f64, + c2: 0f64, + c: Some([ + 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, + ]), +}; +impl RotationalElements for Jupiter { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_JUPITER.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_JUPITER.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_JUPITER.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_JUPITER.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_JUPITER.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_JUPITER.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Saturn; +impl Origin for Saturn { + fn id(&self) -> NaifId { + NaifId(699i32) + } + fn name(&self) -> &'static str { + "Saturn" + } +} +impl Display for Saturn { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Saturn { + fn gravitational_parameter(&self) -> f64 { + 37931206.23436167f64 + } +} +impl MeanRadius for Saturn { + fn mean_radius(&self) -> f64 { + 58232f64 + } +} +impl TriaxialEllipsoid for Saturn { + fn radii(&self) -> Radii { + (60268f64, 60268f64, 54364f64) + } +} +impl Spheroid for Saturn {} +const RIGHT_ASCENSION_SATURN: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.7084116900919784f64, + c1: -0.0006283185307179586f64, + c2: 0f64, + c: None, +}; +const DECLINATION_SATURN: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.457995697238503f64, + c1: -0.00006981317007977319f64, + c2: 0f64, + c: None, +}; +const ROTATION_SATURN: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 0.6789330790257941f64, + c1: 14.151023151973554f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Saturn { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_SATURN.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_SATURN.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_SATURN.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_SATURN.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_SATURN.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_SATURN.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Uranus; +impl Origin for Uranus { + fn id(&self) -> NaifId { + NaifId(799i32) + } + fn name(&self) -> &'static str { + "Uranus" + } +} +impl Display for Uranus { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Uranus { + fn gravitational_parameter(&self) -> f64 { + 5793951.256527211f64 + } +} +impl MeanRadius for Uranus { + fn mean_radius(&self) -> f64 { + 25362f64 + } +} +impl TriaxialEllipsoid for Uranus { + fn radii(&self) -> Radii { + (25559f64, 25559f64, 24973f64) + } +} +impl Spheroid for Uranus {} +const RIGHT_ASCENSION_URANUS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.4909241515991285f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const DECLINATION_URANUS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -0.2648537139901395f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const ROTATION_URANUS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 3.557155548489643f64, + c1: -8.746893698960328f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Uranus { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_URANUS.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_URANUS.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_URANUS.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_URANUS.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_URANUS.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_URANUS.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Neptune; +impl Origin for Neptune { + fn id(&self) -> NaifId { + NaifId(899i32) + } + fn name(&self) -> &'static str { + "Neptune" + } +} +impl Display for Neptune { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Neptune { + fn gravitational_parameter(&self) -> f64 { + 6835103.145462294f64 + } +} +impl MeanRadius for Neptune { + fn mean_radius(&self) -> f64 { + 24622f64 + } +} +impl TriaxialEllipsoid for Neptune { + fn radii(&self) -> Radii { + (24764f64, 24764f64, 24341f64) + } +} +impl Spheroid for Neptune {} +const RIGHT_ASCENSION_NEPTUNE: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 5.224817648770225f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0.012217304763960306f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_NEPTUNE: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 0.7585200929167356f64, + c1: 0f64, + c2: 0f64, + c: Some([ + -0.00890117918517108f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_NEPTUNE: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 4.362939157550385f64, + c1: 9.444670799468602f64, + c2: 0f64, + c: Some([ + -0.008377580409572781f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Neptune { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_NEPTUNE.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_NEPTUNE.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_NEPTUNE.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_NEPTUNE.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_NEPTUNE.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_NEPTUNE.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Pluto; +impl Origin for Pluto { + fn id(&self) -> NaifId { + NaifId(999i32) + } + fn name(&self) -> &'static str { + "Pluto" + } +} +impl Display for Pluto { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Pluto { + fn gravitational_parameter(&self) -> f64 { + 869.6138177608748f64 + } +} +impl MeanRadius for Pluto { + fn mean_radius(&self) -> f64 { + 1188.3f64 + } +} +impl TriaxialEllipsoid for Pluto { + fn radii(&self) -> Radii { + (1188.3f64, 1188.3f64, 1188.3f64) + } +} +impl Spheroid for Pluto {} +const RIGHT_ASCENSION_PLUTO: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 2.3211657321048187f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const DECLINATION_PLUTO: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -0.10756464180041053f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const ROTATION_PLUTO: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 5.283024379324235f64, + c1: 0.9837115923543857f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Pluto { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PLUTO.angle::<0usize>(None, t), + DECLINATION_PLUTO.angle::<0usize>(None, t), + ROTATION_PLUTO.angle::<0usize>(None, t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PLUTO.angle_dot::<0usize>(None, t), + DECLINATION_PLUTO.angle_dot::<0usize>(None, t), + ROTATION_PLUTO.angle_dot::<0usize>(None, t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct SolarSystemBarycenter; +impl Origin for SolarSystemBarycenter { + fn id(&self) -> NaifId { + NaifId(0i32) + } + fn name(&self) -> &'static str { + "Solar System Barycenter" + } +} +impl Display for SolarSystemBarycenter { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for SolarSystemBarycenter { + fn gravitational_parameter(&self) -> f64 { + 132712440041.27942f64 + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct MercuryBarycenter; +impl Origin for MercuryBarycenter { + fn id(&self) -> NaifId { + NaifId(1i32) + } + fn name(&self) -> &'static str { + "Mercury Barycenter" + } +} +impl Display for MercuryBarycenter { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for MercuryBarycenter { + fn gravitational_parameter(&self) -> f64 { + 22031.868551400003f64 + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct VenusBarycenter; +impl Origin for VenusBarycenter { + fn id(&self) -> NaifId { + NaifId(2i32) + } + fn name(&self) -> &'static str { + "Venus Barycenter" + } +} +impl Display for VenusBarycenter { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for VenusBarycenter { + fn gravitational_parameter(&self) -> f64 { + 324858.592f64 + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct EarthBarycenter; +impl Origin for EarthBarycenter { + fn id(&self) -> NaifId { + NaifId(3i32) + } + fn name(&self) -> &'static str { + "Earth Barycenter" + } +} +impl Display for EarthBarycenter { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for EarthBarycenter { + fn gravitational_parameter(&self) -> f64 { + 403503.2356254802f64 + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct MarsBarycenter; +impl Origin for MarsBarycenter { + fn id(&self) -> NaifId { + NaifId(4i32) + } + fn name(&self) -> &'static str { + "Mars Barycenter" + } +} +impl Display for MarsBarycenter { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for MarsBarycenter { + fn gravitational_parameter(&self) -> f64 { + 42828.3758157561f64 + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct JupiterBarycenter; +impl Origin for JupiterBarycenter { + fn id(&self) -> NaifId { + NaifId(5i32) + } + fn name(&self) -> &'static str { + "Jupiter Barycenter" + } +} +impl Display for JupiterBarycenter { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for JupiterBarycenter { + fn gravitational_parameter(&self) -> f64 { + 126712764.09999998f64 + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct SaturnBarycenter; +impl Origin for SaturnBarycenter { + fn id(&self) -> NaifId { + NaifId(6i32) + } + fn name(&self) -> &'static str { + "Saturn Barycenter" + } +} +impl Display for SaturnBarycenter { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for SaturnBarycenter { + fn gravitational_parameter(&self) -> f64 { + 37940584.8418f64 + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct UranusBarycenter; +impl Origin for UranusBarycenter { + fn id(&self) -> NaifId { + NaifId(7i32) + } + fn name(&self) -> &'static str { + "Uranus Barycenter" + } +} +impl Display for UranusBarycenter { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for UranusBarycenter { + fn gravitational_parameter(&self) -> f64 { + 5794556.3999999985f64 + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct NeptuneBarycenter; +impl Origin for NeptuneBarycenter { + fn id(&self) -> NaifId { + NaifId(8i32) + } + fn name(&self) -> &'static str { + "Neptune Barycenter" + } +} +impl Display for NeptuneBarycenter { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for NeptuneBarycenter { + fn gravitational_parameter(&self) -> f64 { + 6836527.100580399f64 + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct PlutoBarycenter; +impl Origin for PlutoBarycenter { + fn id(&self) -> NaifId { + NaifId(9i32) + } + fn name(&self) -> &'static str { + "Pluto Barycenter" + } +} +impl Display for PlutoBarycenter { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for PlutoBarycenter { + fn gravitational_parameter(&self) -> f64 { + 975.5f64 + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Moon; +impl Origin for Moon { + fn id(&self) -> NaifId { + NaifId(301i32) + } + fn name(&self) -> &'static str { + "Moon" + } +} +impl Display for Moon { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Moon { + fn gravitational_parameter(&self) -> f64 { + 4902.80011845755f64 + } +} +impl MeanRadius for Moon { + fn mean_radius(&self) -> f64 { + 1737.4f64 + } +} +impl TriaxialEllipsoid for Moon { + fn radii(&self) -> Radii { + (1737.4f64, 1737.4f64, 1737.4f64) + } +} +impl Spheroid for Moon {} +const RIGHT_ASCENSION_MOON: RotationalElement<13usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.712299968592838f64, + c1: 0.000054105206811824215f64, + c2: 0f64, + c: Some([ + -0.06769608569710406f64, + -0.0021013764194011725f64, + 0.0012217304763960308f64, + -0.0003001966313430247f64, + 0f64, + 0.0001256637061435917f64, + 0f64, + 0f64, + 0f64, + -0.00009075712110370513f64, + 0f64, + 0f64, + 0.00007504915783575618f64, + ]), +}; +const DECLINATION_MOON: RotationalElement<13usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.161328121643011f64, + c1: 0.00022689280275926284f64, + c2: 0f64, + c: Some([ + 0.02691123173650057f64, + 0.0004171336912266448f64, + -0.00048520153205442357f64, + 0.0001186823891356144f64, + 0f64, + -0.00005061454830783555f64, + 0.000015707963267948964f64, + 0f64, + 0f64, + 0.000013962634015954637f64, + 0f64, + 0f64, + -0.000015707963267948964f64, + ]), +}; +const ROTATION_MOON: RotationalElement<13usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 0.668832858644503f64, + c1: 0.22997083313948888f64, + c2: -0.000000000000024434609527920614f64, + c: Some([ + 0.06215117466351808f64, + 0.00210835773640915f64, + -0.0011205013797803594f64, + 0.0002757620218151041f64, + 0.0004398229715025711f64, + -0.00011519173063162575f64, + -0.00008203047484373349f64, + -0.00008028514559173915f64, + 0.000048869219055841225f64, + 0.00009075712110370513f64, + 0.00006981317007977319f64, + 0.00003316125578789226f64, + -0.0000767944870877505f64, + ]), +}; +impl RotationalElements for Moon { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_MOON.angle::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + DECLINATION_MOON.angle::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + ROTATION_MOON.angle::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_MOON.angle_dot::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + DECLINATION_MOON.angle_dot::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + ROTATION_MOON.angle_dot::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Phobos; +impl Origin for Phobos { + fn id(&self) -> NaifId { + NaifId(401i32) + } + fn name(&self) -> &'static str { + "Phobos" + } +} +impl Display for Phobos { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Phobos { + fn gravitational_parameter(&self) -> f64 { + 0.0007087546066894452f64 + } +} +impl MeanRadius for Phobos { + fn mean_radius(&self) -> f64 { + 11.08f64 + } +} +impl TriaxialEllipsoid for Phobos { + fn radii(&self) -> Radii { + (13f64, 11.4f64, 9.1f64) + } +} +const RIGHT_ASCENSION_PHOBOS: RotationalElement<4usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 5.544399941316208f64, + c1: -0.001892691938596266f64, + c2: 0f64, + c: Some([ + -0.031141630416121578f64, + 0.00038621064567151f64, + -0.00017946365486924213f64, + -0.00008300698656022431f64, + ]), +}; +const DECLINATION_PHOBOS: RotationalElement<4usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 0.9230395870244597f64, + c1: -0.0010707081834185127f64, + c2: 0f64, + c: Some([ + -0.018765175709923063f64, + 0.00011669725164439606f64, + -0.00011322648989388013f64, + 0.000049144282945955534f64, + ]), +}; +const ROTATION_PHOBOS: RotationalElement<5usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 0.6141419961301966f64, + c1: 19.702057793318815f64, + c2: 0.00000000016643698911600935f64, + c: Some([ + 0.02485728795564792f64, + -0.0003968499982587423f64, + 0.0000716825922415843f64, + 0.00011029852554073445f64, + -0.019949113350295186f64, + ]), +}; +impl RotationalElements for Phobos { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PHOBOS.angle::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + DECLINATION_PHOBOS.angle::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + ROTATION_PHOBOS.angle::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PHOBOS.angle_dot::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + DECLINATION_PHOBOS.angle_dot::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + ROTATION_PHOBOS.angle_dot::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Deimos; +impl Origin for Deimos { + fn id(&self) -> NaifId { + NaifId(402i32) + } + fn name(&self) -> &'static str { + "Deimos" + } +} +impl Display for Deimos { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Deimos { + fn gravitational_parameter(&self) -> f64 { + 0.00009615569648120313f64 + } +} +impl MeanRadius for Deimos { + fn mean_radius(&self) -> f64 { + 6.2f64 + } +} +impl TriaxialEllipsoid for Deimos { + fn radii(&self) -> Radii { + (7.8f64, 6f64, 5.1f64) + } +} +const RIGHT_ASCENSION_DEIMOS: RotationalElement<10usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 5.526708263174914f64, + c1: -0.0018357397507085887f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.05396867424229676f64, + 0.004010877798556321f64, + 0.0011202666329959662f64, + 0.00044218562371099577f64, + 0.00013590791618817245f64, + ]), +}; +const DECLINATION_DEIMOS: RotationalElement<10usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 0.9339242922383507f64, + c1: -0.0010435487658623783f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.032102888827614605f64, + 0.002500240004017941f64, + 0.00033360380402252296f64, + -0.0002587607695714273f64, + 0.00003358537079612689f64, + ]), +}; +const ROTATION_DEIMOS: RotationalElement<10usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 1.3857797243489947f64, + c1: 4.977013864082068f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.047814137677880446f64, + -0.006975837721323607f64, + -0.0011455047921115052f64, + -0.0005084039391304362f64, + 0.0002965593651818685f64, + ]), +}; +impl RotationalElements for Deimos { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_DEIMOS.angle::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + DECLINATION_DEIMOS.angle::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + ROTATION_DEIMOS.angle::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_DEIMOS.angle_dot::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + DECLINATION_DEIMOS.angle_dot::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + ROTATION_DEIMOS.angle_dot::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Io; +impl Origin for Io { + fn id(&self) -> NaifId { + NaifId(501i32) + } + fn name(&self) -> &'static str { + "Io" + } +} +impl Display for Io { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Io { + fn gravitational_parameter(&self) -> f64 { + 5959.915466180539f64 + } +} +impl MeanRadius for Io { + fn mean_radius(&self) -> f64 { + 1821.49f64 + } +} +impl TriaxialEllipsoid for Io { + fn radii(&self) -> Radii { + (1829.4f64, 1819.4f64, 1815.7f64) + } +} +const RIGHT_ASCENSION_IO: RotationalElement<4usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.678355059970801f64, + c1: -0.00015707963267948965f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0.0016406094968746698f64, + 0.0004188790204786391f64, + ]), +}; +const DECLINATION_IO: RotationalElement<4usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.1257373675363425f64, + c1: 0.00005235987755982989f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0.0006981317007977319f64, + 0.00019198621771937625f64, + ]), +}; +const ROTATION_IO: RotationalElement<4usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 3.4974652880714365f64, + c1: 3.551552235248627f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + -0.0014835298641951802f64, + -0.0003839724354387525f64, + ]), +}; +impl RotationalElements for Io { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_IO.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_IO.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_IO.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_IO.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_IO.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_IO.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Europa; +impl Origin for Europa { + fn id(&self) -> NaifId { + NaifId(502i32) + } + fn name(&self) -> &'static str { + "Europa" + } +} +impl Display for Europa { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Europa { + fn gravitational_parameter(&self) -> f64 { + 3202.712099607295f64 + } +} +impl MeanRadius for Europa { + fn mean_radius(&self) -> f64 { + 1560.8f64 + } +} +impl TriaxialEllipsoid for Europa { + fn radii(&self) -> Radii { + (1562.6f64, 1560.3f64, 1559.5f64) + } +} +const RIGHT_ASCENSION_EUROPA: RotationalElement<7usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.678878658746398f64, + c1: -0.00015707963267948965f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0.01895427567665842f64, + 0.0010471975511965976f64, + 0.0002617993877991494f64, + 0.00015707963267948965f64, + ]), +}; +const DECLINATION_EUROPA: RotationalElement<7usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.125911900461542f64, + c1: 0.00005235987755982989f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0.008168140899333463f64, + 0.0004537856055185257f64, + 0.00012217304763960306f64, + 0.00003490658503988659f64, + ]), +}; +const ROTATION_EUROPA: RotationalElement<7usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 0.6287025031533974f64, + c1: 1.7693227033738699f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + -0.01710422666954443f64, + -0.0009424777960769379f64, + -0.0002443460952792061f64, + -0.00013962634015954637f64, + ]), +}; +impl RotationalElements for Europa { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_EUROPA.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_EUROPA.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_EUROPA.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_EUROPA.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_EUROPA.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_EUROPA.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Ganymede; +impl Origin for Ganymede { + fn id(&self) -> NaifId { + NaifId(503i32) + } + fn name(&self) -> &'static str { + "Ganymede" + } +} +impl Display for Ganymede { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Ganymede { + fn gravitational_parameter(&self) -> f64 { + 9887.832752719638f64 + } +} +impl MeanRadius for Ganymede { + fn mean_radius(&self) -> f64 { + 2631.2f64 + } +} +impl TriaxialEllipsoid for Ganymede { + fn radii(&self) -> Radii { + (2631.2f64, 2631.2f64, 2631.2f64) + } +} +impl Spheroid for Ganymede {} +const RIGHT_ASCENSION_GANYMEDE: RotationalElement<6usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.680973053848792f64, + c1: -0.00015707963267948965f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + -0.0006457718232379018f64, + 0.0075223690760955605f64, + 0.0015882496193148398f64, + ]), +}; +const DECLINATION_GANYMEDE: RotationalElement<6usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.1269590980127384f64, + c1: 0.00005235987755982989f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + -0.00027925268031909274f64, + 0.003246312408709453f64, + 0.0006806784082777885f64, + ]), +}; +const ROTATION_GANYMEDE: RotationalElement<6usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 0.7690618815987814f64, + c1: 0.8782079330731682f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0.0005759586531581288f64, + -0.006789330790257942f64, + -0.0014311699866353504f64, + ]), +}; +impl RotationalElements for Ganymede { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_GANYMEDE.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_GANYMEDE.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_GANYMEDE.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_GANYMEDE.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_GANYMEDE.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_GANYMEDE.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Callisto; +impl Origin for Callisto { + fn id(&self) -> NaifId { + NaifId(504i32) + } + fn name(&self) -> &'static str { + "Callisto" + } +} +impl Display for Callisto { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Callisto { + fn gravitational_parameter(&self) -> f64 { + 7179.283402579837f64 + } +} +impl MeanRadius for Callisto { + fn mean_radius(&self) -> f64 { + 2410.3f64 + } +} +impl TriaxialEllipsoid for Callisto { + fn radii(&self) -> Radii { + (2410.3f64, 2410.3f64, 2410.3f64) + } +} +impl Spheroid for Callisto {} +const RIGHT_ASCENSION_CALLISTO: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.690048765959163f64, + c1: -0.00015707963267948965f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + -0.001186823891356144f64, + 0.010297442586766544f64, + 0f64, + 0.00017453292519943296f64, + ]), +}; +const DECLINATION_CALLISTO: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.1314969540679238f64, + c1: 0.00005235987755982989f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + -0.0005061454830783556f64, + 0.004433136300065597f64, + 0f64, + -0.00006981317007977319f64, + ]), +}; +const ROTATION_CALLISTO: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 4.529303941850484f64, + c1: 0.37648622085811195f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0.001064650843716541f64, + -0.009302604913129777f64, + 0f64, + -0.00015707963267948965f64, + ]), +}; +impl RotationalElements for Callisto { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_CALLISTO.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_CALLISTO.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_CALLISTO.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_CALLISTO.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_CALLISTO.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_CALLISTO.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Amalthea; +impl Origin for Amalthea { + fn id(&self) -> NaifId { + NaifId(505i32) + } + fn name(&self) -> &'static str { + "Amalthea" + } +} +impl Display for Amalthea { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Amalthea { + fn gravitational_parameter(&self) -> f64 { + 0.1645634534798259f64 + } +} +impl MeanRadius for Amalthea { + fn mean_radius(&self) -> f64 { + 83.5f64 + } +} +impl TriaxialEllipsoid for Amalthea { + fn radii(&self) -> Radii { + (125f64, 73f64, 64f64) + } +} +const RIGHT_ASCENSION_AMALTHEA: RotationalElement<10usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.678355059970801f64, + c1: -0.00015707963267948965f64, + c2: 0f64, + c: Some([ + -0.014660765716752368f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.00017453292519943296f64, + 0f64, + ]), +}; +const DECLINATION_AMALTHEA: RotationalElement<10usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.125562834611143f64, + c1: 0.00005235987755982989f64, + c2: 0f64, + c: Some([ + -0.006283185307179586f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_AMALTHEA: RotationalElement<10usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 4.043404278095263f64, + c1: 12.612298185680531f64, + c2: 0f64, + c: Some([ + 0.013264502315156905f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.00017453292519943296f64, + 0f64, + ]), +}; +impl RotationalElements for Amalthea { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_AMALTHEA.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_AMALTHEA.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_AMALTHEA.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_AMALTHEA.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_AMALTHEA.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_AMALTHEA.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Himalia; +impl Origin for Himalia { + fn id(&self) -> NaifId { + NaifId(506i32) + } + fn name(&self) -> &'static str { + "Himalia" + } +} +impl Display for Himalia { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Himalia { + fn gravitational_parameter(&self) -> f64 { + 0.1515524299611265f64 + } +} +impl MeanRadius for Himalia { + fn mean_radius(&self) -> f64 { + 85f64 + } +} +impl TriaxialEllipsoid for Himalia { + fn radii(&self) -> Radii { + (85f64, 85f64, 85f64) + } +} +impl Spheroid for Himalia {} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Elara; +impl Origin for Elara { + fn id(&self) -> NaifId { + NaifId(507i32) + } + fn name(&self) -> &'static str { + "Elara" + } +} +impl Display for Elara { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Elara { + fn mean_radius(&self) -> f64 { + 40f64 + } +} +impl TriaxialEllipsoid for Elara { + fn radii(&self) -> Radii { + (40f64, 40f64, 40f64) + } +} +impl Spheroid for Elara {} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Pasiphae; +impl Origin for Pasiphae { + fn id(&self) -> NaifId { + NaifId(508i32) + } + fn name(&self) -> &'static str { + "Pasiphae" + } +} +impl Display for Pasiphae { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Pasiphae { + fn mean_radius(&self) -> f64 { + 18f64 + } +} +impl TriaxialEllipsoid for Pasiphae { + fn radii(&self) -> Radii { + (18f64, 18f64, 18f64) + } +} +impl Spheroid for Pasiphae {} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Sinope; +impl Origin for Sinope { + fn id(&self) -> NaifId { + NaifId(509i32) + } + fn name(&self) -> &'static str { + "Sinope" + } +} +impl Display for Sinope { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Sinope { + fn mean_radius(&self) -> f64 { + 14f64 + } +} +impl TriaxialEllipsoid for Sinope { + fn radii(&self) -> Radii { + (14f64, 14f64, 14f64) + } +} +impl Spheroid for Sinope {} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Lysithea; +impl Origin for Lysithea { + fn id(&self) -> NaifId { + NaifId(510i32) + } + fn name(&self) -> &'static str { + "Lysithea" + } +} +impl Display for Lysithea { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Lysithea { + fn mean_radius(&self) -> f64 { + 12f64 + } +} +impl TriaxialEllipsoid for Lysithea { + fn radii(&self) -> Radii { + (12f64, 12f64, 12f64) + } +} +impl Spheroid for Lysithea {} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Carme; +impl Origin for Carme { + fn id(&self) -> NaifId { + NaifId(511i32) + } + fn name(&self) -> &'static str { + "Carme" + } +} +impl Display for Carme { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Carme { + fn mean_radius(&self) -> f64 { + 15f64 + } +} +impl TriaxialEllipsoid for Carme { + fn radii(&self) -> Radii { + (15f64, 15f64, 15f64) + } +} +impl Spheroid for Carme {} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Ananke; +impl Origin for Ananke { + fn id(&self) -> NaifId { + NaifId(512i32) + } + fn name(&self) -> &'static str { + "Ananke" + } +} +impl Display for Ananke { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Ananke { + fn mean_radius(&self) -> f64 { + 10f64 + } +} +impl TriaxialEllipsoid for Ananke { + fn radii(&self) -> Radii { + (10f64, 10f64, 10f64) + } +} +impl Spheroid for Ananke {} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Leda; +impl Origin for Leda { + fn id(&self) -> NaifId { + NaifId(513i32) + } + fn name(&self) -> &'static str { + "Leda" + } +} +impl Display for Leda { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Leda { + fn mean_radius(&self) -> f64 { + 5f64 + } +} +impl TriaxialEllipsoid for Leda { + fn radii(&self) -> Radii { + (5f64, 5f64, 5f64) + } +} +impl Spheroid for Leda {} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Thebe; +impl Origin for Thebe { + fn id(&self) -> NaifId { + NaifId(514i32) + } + fn name(&self) -> &'static str { + "Thebe" + } +} +impl Display for Thebe { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Thebe { + fn gravitational_parameter(&self) -> f64 { + 0.030148f64 + } +} +impl MeanRadius for Thebe { + fn mean_radius(&self) -> f64 { + 49.3f64 + } +} +impl TriaxialEllipsoid for Thebe { + fn radii(&self) -> Radii { + (58f64, 49f64, 42f64) + } +} +const RIGHT_ASCENSION_THEBE: RotationalElement<10usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.678355059970801f64, + c1: -0.00015707963267948965f64, + c2: 0f64, + c: Some([ + 0f64, + -0.03682644721708035f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.0006981317007977319f64, + ]), +}; +const DECLINATION_THEBE: RotationalElement<10usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.125562834611143f64, + c1: 0.00005235987755982989f64, + c2: 0f64, + c: Some([ + 0f64, + -0.0158824961931484f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.00017453292519943296f64, + ]), +}; +const ROTATION_THEBE: RotationalElement<10usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 0.1494001839707146f64, + c1: 9.31482937374367f64, + c2: 0f64, + c: Some([ + 0f64, + 0.033335788713091695f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.0006981317007977319f64, + ]), +}; +impl RotationalElements for Thebe { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_THEBE.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_THEBE.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_THEBE.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_THEBE.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_THEBE.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_THEBE.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Adrastea; +impl Origin for Adrastea { + fn id(&self) -> NaifId { + NaifId(515i32) + } + fn name(&self) -> &'static str { + "Adrastea" + } +} +impl Display for Adrastea { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Adrastea { + fn gravitational_parameter(&self) -> f64 { + 0.000139f64 + } +} +impl MeanRadius for Adrastea { + fn mean_radius(&self) -> f64 { + 8.2f64 + } +} +impl TriaxialEllipsoid for Adrastea { + fn radii(&self) -> Radii { + (10f64, 8f64, 7f64) + } +} +const RIGHT_ASCENSION_ADRASTEA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.678355059970801f64, + c1: -0.00015707963267948965f64, + c2: 0f64, + c: None, +}; +const DECLINATION_ADRASTEA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.125562834611143f64, + c1: 0.00005235987755982989f64, + c2: 0f64, + c: None, +}; +const ROTATION_ADRASTEA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 0.5810201079889122f64, + c1: 21.066100687650238f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Adrastea { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_ADRASTEA.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_ADRASTEA.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_ADRASTEA.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_ADRASTEA.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_ADRASTEA.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_ADRASTEA.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Metis; +impl Origin for Metis { + fn id(&self) -> NaifId { + NaifId(516i32) + } + fn name(&self) -> &'static str { + "Metis" + } +} +impl Display for Metis { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Metis { + fn gravitational_parameter(&self) -> f64 { + 0.002501f64 + } +} +impl MeanRadius for Metis { + fn mean_radius(&self) -> f64 { + 21.5f64 + } +} +impl TriaxialEllipsoid for Metis { + fn radii(&self) -> Radii { + (30f64, 20f64, 17f64) + } +} +const RIGHT_ASCENSION_METIS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.678355059970801f64, + c1: -0.00015707963267948965f64, + c2: 0f64, + c: None, +}; +const DECLINATION_METIS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.125562834611143f64, + c1: 0.00005235987755982989f64, + c2: 0f64, + c: None, +}; +const ROTATION_METIS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 6.040410008227175f64, + c1: 21.3149160457997f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Metis { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_METIS.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_METIS.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_METIS.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_METIS.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_METIS.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_METIS.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Callirrhoe; +impl Origin for Callirrhoe { + fn id(&self) -> NaifId { + NaifId(517i32) + } + fn name(&self) -> &'static str { + "Callirrhoe" + } +} +impl Display for Callirrhoe { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Themisto; +impl Origin for Themisto { + fn id(&self) -> NaifId { + NaifId(518i32) + } + fn name(&self) -> &'static str { + "Themisto" + } +} +impl Display for Themisto { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Magaclite; +impl Origin for Magaclite { + fn id(&self) -> NaifId { + NaifId(519i32) + } + fn name(&self) -> &'static str { + "Magaclite" + } +} +impl Display for Magaclite { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Taygete; +impl Origin for Taygete { + fn id(&self) -> NaifId { + NaifId(520i32) + } + fn name(&self) -> &'static str { + "Taygete" + } +} +impl Display for Taygete { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Chaldene; +impl Origin for Chaldene { + fn id(&self) -> NaifId { + NaifId(521i32) + } + fn name(&self) -> &'static str { + "Chaldene" + } +} +impl Display for Chaldene { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Harpalyke; +impl Origin for Harpalyke { + fn id(&self) -> NaifId { + NaifId(522i32) + } + fn name(&self) -> &'static str { + "Harpalyke" + } +} +impl Display for Harpalyke { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Kalyke; +impl Origin for Kalyke { + fn id(&self) -> NaifId { + NaifId(523i32) + } + fn name(&self) -> &'static str { + "Kalyke" + } +} +impl Display for Kalyke { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Iocaste; +impl Origin for Iocaste { + fn id(&self) -> NaifId { + NaifId(524i32) + } + fn name(&self) -> &'static str { + "Iocaste" + } +} +impl Display for Iocaste { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Erinome; +impl Origin for Erinome { + fn id(&self) -> NaifId { + NaifId(525i32) + } + fn name(&self) -> &'static str { + "Erinome" + } +} +impl Display for Erinome { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Isonoe; +impl Origin for Isonoe { + fn id(&self) -> NaifId { + NaifId(526i32) + } + fn name(&self) -> &'static str { + "Isonoe" + } +} +impl Display for Isonoe { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Praxidike; +impl Origin for Praxidike { + fn id(&self) -> NaifId { + NaifId(527i32) + } + fn name(&self) -> &'static str { + "Praxidike" + } +} +impl Display for Praxidike { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Autonoe; +impl Origin for Autonoe { + fn id(&self) -> NaifId { + NaifId(528i32) + } + fn name(&self) -> &'static str { + "Autonoe" + } +} +impl Display for Autonoe { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Thyone; +impl Origin for Thyone { + fn id(&self) -> NaifId { + NaifId(529i32) + } + fn name(&self) -> &'static str { + "Thyone" + } +} +impl Display for Thyone { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Hermippe; +impl Origin for Hermippe { + fn id(&self) -> NaifId { + NaifId(530i32) + } + fn name(&self) -> &'static str { + "Hermippe" + } +} +impl Display for Hermippe { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Aitne; +impl Origin for Aitne { + fn id(&self) -> NaifId { + NaifId(531i32) + } + fn name(&self) -> &'static str { + "Aitne" + } +} +impl Display for Aitne { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Eurydome; +impl Origin for Eurydome { + fn id(&self) -> NaifId { + NaifId(532i32) + } + fn name(&self) -> &'static str { + "Eurydome" + } +} +impl Display for Eurydome { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Euanthe; +impl Origin for Euanthe { + fn id(&self) -> NaifId { + NaifId(533i32) + } + fn name(&self) -> &'static str { + "Euanthe" + } +} +impl Display for Euanthe { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Euporie; +impl Origin for Euporie { + fn id(&self) -> NaifId { + NaifId(534i32) + } + fn name(&self) -> &'static str { + "Euporie" + } +} +impl Display for Euporie { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Orthosie; +impl Origin for Orthosie { + fn id(&self) -> NaifId { + NaifId(535i32) + } + fn name(&self) -> &'static str { + "Orthosie" + } +} +impl Display for Orthosie { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Sponde; +impl Origin for Sponde { + fn id(&self) -> NaifId { + NaifId(536i32) + } + fn name(&self) -> &'static str { + "Sponde" + } +} +impl Display for Sponde { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Kale; +impl Origin for Kale { + fn id(&self) -> NaifId { + NaifId(537i32) + } + fn name(&self) -> &'static str { + "Kale" + } +} +impl Display for Kale { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Pasithee; +impl Origin for Pasithee { + fn id(&self) -> NaifId { + NaifId(538i32) + } + fn name(&self) -> &'static str { + "Pasithee" + } +} +impl Display for Pasithee { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Hegemone; +impl Origin for Hegemone { + fn id(&self) -> NaifId { + NaifId(539i32) + } + fn name(&self) -> &'static str { + "Hegemone" + } +} +impl Display for Hegemone { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Mneme; +impl Origin for Mneme { + fn id(&self) -> NaifId { + NaifId(540i32) + } + fn name(&self) -> &'static str { + "Mneme" + } +} +impl Display for Mneme { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Aoede; +impl Origin for Aoede { + fn id(&self) -> NaifId { + NaifId(541i32) + } + fn name(&self) -> &'static str { + "Aoede" + } +} +impl Display for Aoede { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Thelxinoe; +impl Origin for Thelxinoe { + fn id(&self) -> NaifId { + NaifId(542i32) + } + fn name(&self) -> &'static str { + "Thelxinoe" + } +} +impl Display for Thelxinoe { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Arche; +impl Origin for Arche { + fn id(&self) -> NaifId { + NaifId(543i32) + } + fn name(&self) -> &'static str { + "Arche" + } +} +impl Display for Arche { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Kallichore; +impl Origin for Kallichore { + fn id(&self) -> NaifId { + NaifId(544i32) + } + fn name(&self) -> &'static str { + "Kallichore" + } +} +impl Display for Kallichore { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Helike; +impl Origin for Helike { + fn id(&self) -> NaifId { + NaifId(545i32) + } + fn name(&self) -> &'static str { + "Helike" + } +} +impl Display for Helike { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Carpo; +impl Origin for Carpo { + fn id(&self) -> NaifId { + NaifId(546i32) + } + fn name(&self) -> &'static str { + "Carpo" + } +} +impl Display for Carpo { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Eukelade; +impl Origin for Eukelade { + fn id(&self) -> NaifId { + NaifId(547i32) + } + fn name(&self) -> &'static str { + "Eukelade" + } +} +impl Display for Eukelade { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Cyllene; +impl Origin for Cyllene { + fn id(&self) -> NaifId { + NaifId(548i32) + } + fn name(&self) -> &'static str { + "Cyllene" + } +} +impl Display for Cyllene { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Kore; +impl Origin for Kore { + fn id(&self) -> NaifId { + NaifId(549i32) + } + fn name(&self) -> &'static str { + "Kore" + } +} +impl Display for Kore { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Herse; +impl Origin for Herse { + fn id(&self) -> NaifId { + NaifId(550i32) + } + fn name(&self) -> &'static str { + "Herse" + } +} +impl Display for Herse { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Dia; +impl Origin for Dia { + fn id(&self) -> NaifId { + NaifId(553i32) + } + fn name(&self) -> &'static str { + "Dia" + } +} +impl Display for Dia { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Mimas; +impl Origin for Mimas { + fn id(&self) -> NaifId { + NaifId(601i32) + } + fn name(&self) -> &'static str { + "Mimas" + } +} +impl Display for Mimas { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Mimas { + fn gravitational_parameter(&self) -> f64 { + 2.503488768152587f64 + } +} +impl MeanRadius for Mimas { + fn mean_radius(&self) -> f64 { + 198.2f64 + } +} +impl TriaxialEllipsoid for Mimas { + fn radii(&self) -> Radii { + (207.8f64, 196.7f64, 190.6f64) + } +} +const RIGHT_ASCENSION_MIMAS: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.7096508738608943f64, + c1: -0.0006283185307179586f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0.2366666465704311f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_MIMAS: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.457698991265664f64, + c1: -0.00006981317007977319f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + -0.026703537555513242f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_MIMAS: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 5.819974923700291f64, + c1: 6.667062709440567f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + -0.23527038316883564f64, + 0f64, + -0.7827801695194568f64, + 0f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Mimas { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_MIMAS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_MIMAS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_MIMAS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_MIMAS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_MIMAS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_MIMAS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Enceladus; +impl Origin for Enceladus { + fn id(&self) -> NaifId { + NaifId(602i32) + } + fn name(&self) -> &'static str { + "Enceladus" + } +} +impl Display for Enceladus { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Enceladus { + fn gravitational_parameter(&self) -> f64 { + 7.210366688598896f64 + } +} +impl MeanRadius for Enceladus { + fn mean_radius(&self) -> f64 { + 252.1f64 + } +} +impl TriaxialEllipsoid for Enceladus { + fn radii(&self) -> Radii { + (256.6f64, 251.4f64, 248.3f64) + } +} +const RIGHT_ASCENSION_ENCELADUS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.7096508738608943f64, + c1: -0.0006283185307179586f64, + c2: 0f64, + c: None, +}; +const DECLINATION_ENCELADUS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.457698991265664f64, + c1: -0.00006981317007977319f64, + c2: 0f64, + c: None, +}; +const ROTATION_ENCELADUS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 0.11030480872604163f64, + c1: 4.585536698039173f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Enceladus { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_ENCELADUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_ENCELADUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_ENCELADUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_ENCELADUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_ENCELADUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_ENCELADUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Tethys; +impl Origin for Tethys { + fn id(&self) -> NaifId { + NaifId(603i32) + } + fn name(&self) -> &'static str { + "Tethys" + } +} +impl Display for Tethys { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Tethys { + fn gravitational_parameter(&self) -> f64 { + 41.21352885489587f64 + } +} +impl MeanRadius for Tethys { + fn mean_radius(&self) -> f64 { + 531f64 + } +} +impl TriaxialEllipsoid for Tethys { + fn radii(&self) -> Radii { + (538.4f64, 528.3f64, 526.3f64) + } +} +const RIGHT_ASCENSION_TETHYS: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.7096508738608943f64, + c1: -0.0006283185307179586f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0.16859880574265224f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_TETHYS: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.457698991265664f64, + c1: -0.00006981317007977319f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + -0.019024088846738195f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_TETHYS: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 0.1562069680534925f64, + c1: 3.328306379991881f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + -0.16755160819145562f64, + 0.03892084231947355f64, + 0f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Tethys { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_TETHYS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_TETHYS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_TETHYS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_TETHYS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_TETHYS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_TETHYS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Dione; +impl Origin for Dione { + fn id(&self) -> NaifId { + NaifId(604i32) + } + fn name(&self) -> &'static str { + "Dione" + } +} +impl Display for Dione { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Dione { + fn gravitational_parameter(&self) -> f64 { + 73.11607172482067f64 + } +} +impl MeanRadius for Dione { + fn mean_radius(&self) -> f64 { + 561.4f64 + } +} +impl TriaxialEllipsoid for Dione { + fn radii(&self) -> Radii { + (563.4f64, 561.3f64, 559.6f64) + } +} +const RIGHT_ASCENSION_DIONE: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.7096508738608943f64, + c1: -0.0006283185307179586f64, + c2: 0f64, + c: None, +}; +const DECLINATION_DIONE: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.457698991265664f64, + c1: -0.00006981317007977319f64, + c2: 0f64, + c: None, +}; +const ROTATION_DIONE: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 6.241297405131723f64, + c1: 2.295717637805533f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Dione { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_DIONE.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_DIONE.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_DIONE.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_DIONE.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_DIONE.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_DIONE.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Rhea; +impl Origin for Rhea { + fn id(&self) -> NaifId { + NaifId(605i32) + } + fn name(&self) -> &'static str { + "Rhea" + } +} +impl Display for Rhea { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Rhea { + fn gravitational_parameter(&self) -> f64 { + 153.9417519146563f64 + } +} +impl MeanRadius for Rhea { + fn mean_radius(&self) -> f64 { + 763.5f64 + } +} +impl TriaxialEllipsoid for Rhea { + fn radii(&self) -> Radii { + (765f64, 763.1f64, 762.4f64) + } +} +const RIGHT_ASCENSION_RHEA: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.7047639519553103f64, + c1: -0.0006283185307179586f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.054105206811824215f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_RHEA: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.4582225900412622f64, + c1: -0.00006981317007977319f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.006108652381980153f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_RHEA: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 4.104316268989865f64, + c1: 1.3908537151816638f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.05375614096142535f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Rhea { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_RHEA.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_RHEA.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_RHEA.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_RHEA.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_RHEA.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_RHEA.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Titan; +impl Origin for Titan { + fn id(&self) -> NaifId { + NaifId(606i32) + } + fn name(&self) -> &'static str { + "Titan" + } +} +impl Display for Titan { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Titan { + fn gravitational_parameter(&self) -> f64 { + 8978.137095521046f64 + } +} +impl MeanRadius for Titan { + fn mean_radius(&self) -> f64 { + 2575f64 + } +} +impl TriaxialEllipsoid for Titan { + fn radii(&self) -> Radii { + (2575.15f64, 2574.78f64, 2574.47f64) + } +} +const RIGHT_ASCENSION_TITAN: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.6891031125771652f64, + c1: 0f64, + c2: 0f64, + c: Some([0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64]), +}; +const DECLINATION_TITAN: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.456091543024577f64, + c1: 0f64, + c2: 0f64, + c: Some([0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64]), +}; +const ROTATION_TITAN: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 3.2565313114798795f64, + c1: 0.39404258030637335f64, + c2: 0f64, + c: Some([0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64]), +}; +impl RotationalElements for Titan { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_TITAN.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_TITAN.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_TITAN.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_TITAN.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_TITAN.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_TITAN.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Hyperion; +impl Origin for Hyperion { + fn id(&self) -> NaifId { + NaifId(607i32) + } + fn name(&self) -> &'static str { + "Hyperion" + } +} +impl Display for Hyperion { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Hyperion { + fn gravitational_parameter(&self) -> f64 { + 0.3704913747932265f64 + } +} +impl MeanRadius for Hyperion { + fn mean_radius(&self) -> f64 { + 135f64 + } +} +impl TriaxialEllipsoid for Hyperion { + fn radii(&self) -> Radii { + (180.1f64, 133f64, 102.7f64) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Iapetus; +impl Origin for Iapetus { + fn id(&self) -> NaifId { + NaifId(608i32) + } + fn name(&self) -> &'static str { + "Iapetus" + } +} +impl Display for Iapetus { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Iapetus { + fn gravitational_parameter(&self) -> f64 { + 120.5151060137642f64 + } +} +impl MeanRadius for Iapetus { + fn mean_radius(&self) -> f64 { + 734.3f64 + } +} +impl TriaxialEllipsoid for Iapetus { + fn radii(&self) -> Radii { + (745.7f64, 745.7f64, 712.1f64) + } +} +impl Spheroid for Iapetus {} +const RIGHT_ASCENSION_IAPETUS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 5.552939548145159f64, + c1: -0.06892305216125608f64, + c2: 0f64, + c: None, +}; +const DECLINATION_IAPETUS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.3095205377713455f64, + c1: -0.019949113350295186f64, + c2: 0f64, + c: None, +}; +const ROTATION_IAPETUS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 6.199409503083858f64, + c1: 0.07920229445458282f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Iapetus { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_IAPETUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_IAPETUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_IAPETUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_IAPETUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_IAPETUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_IAPETUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Phoebe; +impl Origin for Phoebe { + fn id(&self) -> NaifId { + NaifId(609i32) + } + fn name(&self) -> &'static str { + "Phoebe" + } +} +impl Display for Phoebe { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Phoebe { + fn gravitational_parameter(&self) -> f64 { + 0.5547860052791678f64 + } +} +impl MeanRadius for Phoebe { + fn mean_radius(&self) -> f64 { + 106.5f64 + } +} +impl TriaxialEllipsoid for Phoebe { + fn radii(&self) -> Radii { + (109.4f64, 108.5f64, 101.8f64) + } +} +const RIGHT_ASCENSION_PHOEBE: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 6.229080100367762f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const DECLINATION_PHOEBE: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.3578661580515883f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const ROTATION_PHOEBE: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 3.116808978211474f64, + c1: 16.26016798998745f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Phoebe { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PHOEBE.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_PHOEBE.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_PHOEBE.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PHOEBE.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_PHOEBE.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_PHOEBE.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Janus; +impl Origin for Janus { + fn id(&self) -> NaifId { + NaifId(610i32) + } + fn name(&self) -> &'static str { + "Janus" + } +} +impl Display for Janus { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Janus { + fn gravitational_parameter(&self) -> f64 { + 0.1265765099012197f64 + } +} +impl MeanRadius for Janus { + fn mean_radius(&self) -> f64 { + 89.2f64 + } +} +impl TriaxialEllipsoid for Janus { + fn radii(&self) -> Radii { + (101.7f64, 93f64, 76.3f64) + } +} +const RIGHT_ASCENSION_JANUS: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.7082546104592989f64, + c1: -0.0006283185307179586f64, + c2: 0f64, + c: Some([ + 0f64, + -0.028326693759867967f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.0004014257279586958f64, + ]), +}; +const DECLINATION_JANUS: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.457698991265664f64, + c1: -0.00006981317007977319f64, + c2: 0f64, + c: Some([ + 0f64, + -0.003193952531149623f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.000017453292519943296f64, + ]), +}; +const ROTATION_JANUS: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 1.0267771989482641f64, + c1: 9.044924285944507f64, + c2: 0f64, + c: Some([ + 0f64, + 0.028152160834668535f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.0004014257279586958f64, + ]), +}; +impl RotationalElements for Janus { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_JANUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_JANUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_JANUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_JANUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_JANUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_JANUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Epimetheus; +impl Origin for Epimetheus { + fn id(&self) -> NaifId { + NaifId(611i32) + } + fn name(&self) -> &'static str { + "Epimetheus" + } +} +impl Display for Epimetheus { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Epimetheus { + fn gravitational_parameter(&self) -> f64 { + 0.03512333288208074f64 + } +} +impl MeanRadius for Epimetheus { + fn mean_radius(&self) -> f64 { + 58.2f64 + } +} +impl TriaxialEllipsoid for Epimetheus { + fn radii(&self) -> Radii { + (64.9f64, 57.3f64, 53f64) + } +} +const RIGHT_ASCENSION_EPIMETHEUS: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.7082546104592989f64, + c1: -0.0006283185307179586f64, + c2: 0f64, + c: Some([ + -0.05503023131538121f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.0015009831567151233f64, + 0f64, + ]), +}; +const DECLINATION_EPIMETHEUS: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.457698991265664f64, + c1: -0.00006981317007977319f64, + c2: 0f64, + c: Some([ + -0.006213372137099813f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.00008726646259971648f64, + 0f64, + ]), +}; +const ROTATION_EPIMETHEUS: RotationalElement<8usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 5.128999072835736f64, + c1: 9.049370273103856f64, + c2: 0f64, + c: Some([ + 0.05468116546498235f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.0015009831567151233f64, + 0f64, + ]), +}; +impl RotationalElements for Epimetheus { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_EPIMETHEUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_EPIMETHEUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_EPIMETHEUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_EPIMETHEUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_EPIMETHEUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_EPIMETHEUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Helene; +impl Origin for Helene { + fn id(&self) -> NaifId { + NaifId(612i32) + } + fn name(&self) -> &'static str { + "Helene" + } +} +impl Display for Helene { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Helene { + fn gravitational_parameter(&self) -> f64 { + 0.0004757419551776972f64 + } +} +impl MeanRadius for Helene { + fn mean_radius(&self) -> f64 { + 18f64 + } +} +impl TriaxialEllipsoid for Helene { + fn radii(&self) -> Radii { + (22.5f64, 19.6f64, 13.3f64) + } +} +const RIGHT_ASCENSION_HELENE: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.7129669994396837f64, + c1: -0.0006283185307179586f64, + c2: 0f64, + c: None, +}; +const DECLINATION_HELENE: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.4545573986120743f64, + c1: -0.00006981317007977319f64, + c2: 0f64, + c: None, +}; +const ROTATION_HELENE: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 4.278151062488501f64, + c1: 2.297157080652823f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Helene { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_HELENE.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_HELENE.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_HELENE.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_HELENE.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_HELENE.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_HELENE.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Telesto; +impl Origin for Telesto { + fn id(&self) -> NaifId { + NaifId(613i32) + } + fn name(&self) -> &'static str { + "Telesto" + } +} +impl Display for Telesto { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Telesto { + fn mean_radius(&self) -> f64 { + 12.4f64 + } +} +impl TriaxialEllipsoid for Telesto { + fn radii(&self) -> Radii { + (16.3f64, 11.8f64, 9.8f64) + } +} +const RIGHT_ASCENSION_TELESTO: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.8815658051823358f64, + c1: -0.0006283185307179586f64, + c2: 0f64, + c: None, +}; +const DECLINATION_TELESTO: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.4671237692264334f64, + c1: -0.00006981317007977319f64, + c2: 0f64, + c: None, +}; +const ROTATION_TELESTO: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 0.9927432785343747f64, + c1: 3.328306811088206f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Telesto { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_TELESTO.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_TELESTO.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_TELESTO.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_TELESTO.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_TELESTO.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_TELESTO.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Calypso; +impl Origin for Calypso { + fn id(&self) -> NaifId { + NaifId(614i32) + } + fn name(&self) -> &'static str { + "Calypso" + } +} +impl Display for Calypso { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Calypso { + fn mean_radius(&self) -> f64 { + 9.6f64 + } +} +impl TriaxialEllipsoid for Calypso { + fn radii(&self) -> Radii { + (15.3f64, 9.3f64, 6.3f64) + } +} +const RIGHT_ASCENSION_CALYPSO: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.6354743806511354f64, + c1: -0.0006283185307179586f64, + c2: 0f64, + c: None, +}; +const DECLINATION_CALYPSO: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.4842279958959779f64, + c1: -0.00006981317007977319f64, + c2: 0f64, + c: None, +}; +const ROTATION_CALYPSO: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 2.679254934736495f64, + c1: 3.327893239613983f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Calypso { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_CALYPSO.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_CALYPSO.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_CALYPSO.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_CALYPSO.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_CALYPSO.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_CALYPSO.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Atlas; +impl Origin for Atlas { + fn id(&self) -> NaifId { + NaifId(615i32) + } + fn name(&self) -> &'static str { + "Atlas" + } +} +impl Display for Atlas { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Atlas { + fn gravitational_parameter(&self) -> f64 { + 0.0003718871247516475f64 + } +} +impl MeanRadius for Atlas { + fn mean_radius(&self) -> f64 { + 15.1f64 + } +} +impl TriaxialEllipsoid for Atlas { + fn radii(&self) -> Radii { + (20.5f64, 17.8f64, 9.4f64) + } +} +const RIGHT_ASCENSION_ATLAS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.7082546104592989f64, + c1: -0.0006283185307179586f64, + c2: 0f64, + c: None, +}; +const DECLINATION_ATLAS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.4578735241908636f64, + c1: -0.00006981317007977319f64, + c2: 0f64, + c: None, +}; +const ROTATION_ATLAS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 2.4064599726497815f64, + c1: 10.442409634437194f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Atlas { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_ATLAS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_ATLAS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_ATLAS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_ATLAS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_ATLAS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_ATLAS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Prometheus; +impl Origin for Prometheus { + fn id(&self) -> NaifId { + NaifId(616i32) + } + fn name(&self) -> &'static str { + "Prometheus" + } +} +impl Display for Prometheus { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Prometheus { + fn gravitational_parameter(&self) -> f64 { + 0.0107520800100761f64 + } +} +impl MeanRadius for Prometheus { + fn mean_radius(&self) -> f64 { + 43.1f64 + } +} +impl TriaxialEllipsoid for Prometheus { + fn radii(&self) -> Radii { + (68.2f64, 41.6f64, 28.2f64) + } +} +const RIGHT_ASCENSION_PROMETHEUS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.7082546104592989f64, + c1: -0.0006283185307179586f64, + c2: 0f64, + c: None, +}; +const DECLINATION_PROMETHEUS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.4578735241908636f64, + c1: -0.00006981317007977319f64, + c2: 0f64, + c: None, +}; +const ROTATION_PROMETHEUS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 5.1686180468560075f64, + c1: 10.250126710744977f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Prometheus { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PROMETHEUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_PROMETHEUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_PROMETHEUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PROMETHEUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_PROMETHEUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_PROMETHEUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Pandora; +impl Origin for Pandora { + fn id(&self) -> NaifId { + NaifId(617i32) + } + fn name(&self) -> &'static str { + "Pandora" + } +} +impl Display for Pandora { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Pandora { + fn gravitational_parameter(&self) -> f64 { + 0.009290325122028795f64 + } +} +impl MeanRadius for Pandora { + fn mean_radius(&self) -> f64 { + 40.6f64 + } +} +impl TriaxialEllipsoid for Pandora { + fn radii(&self) -> Radii { + (52.2f64, 40.8f64, 31.5f64) + } +} +const RIGHT_ASCENSION_PANDORA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.7082546104592989f64, + c1: -0.0006283185307179586f64, + c2: 0f64, + c: None, +}; +const DECLINATION_PANDORA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.4578735241908636f64, + c1: -0.00006981317007977319f64, + c2: 0f64, + c: None, +}; +const ROTATION_PANDORA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 2.8434904173491615f64, + c1: 9.997055714535051f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Pandora { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PANDORA.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_PANDORA.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_PANDORA.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PANDORA.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_PANDORA.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_PANDORA.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Pan; +impl Origin for Pan { + fn id(&self) -> NaifId { + NaifId(618i32) + } + fn name(&self) -> &'static str { + "Pan" + } +} +impl Display for Pan { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Pan { + fn mean_radius(&self) -> f64 { + 14f64 + } +} +impl TriaxialEllipsoid for Pan { + fn radii(&self) -> Radii { + (17.2f64, 15.4f64, 10.4f64) + } +} +const RIGHT_ASCENSION_PAN: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.7086036763096978f64, + c1: -0.0006283185307179586f64, + c2: 0f64, + c: None, +}; +const DECLINATION_PAN: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.457349925415265f64, + c1: -0.00006981317007977319f64, + c2: 0f64, + c: None, +}; +const ROTATION_PAN: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 0.8517206749732328f64, + c1: 10.92652906235538f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Pan { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PAN.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_PAN.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_PAN.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PAN.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_PAN.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_PAN.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Ymir; +impl Origin for Ymir { + fn id(&self) -> NaifId { + NaifId(619i32) + } + fn name(&self) -> &'static str { + "Ymir" + } +} +impl Display for Ymir { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Paaliaq; +impl Origin for Paaliaq { + fn id(&self) -> NaifId { + NaifId(620i32) + } + fn name(&self) -> &'static str { + "Paaliaq" + } +} +impl Display for Paaliaq { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Tarvos; +impl Origin for Tarvos { + fn id(&self) -> NaifId { + NaifId(621i32) + } + fn name(&self) -> &'static str { + "Tarvos" + } +} +impl Display for Tarvos { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Ijiraq; +impl Origin for Ijiraq { + fn id(&self) -> NaifId { + NaifId(622i32) + } + fn name(&self) -> &'static str { + "Ijiraq" + } +} +impl Display for Ijiraq { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Suttungr; +impl Origin for Suttungr { + fn id(&self) -> NaifId { + NaifId(623i32) + } + fn name(&self) -> &'static str { + "Suttungr" + } +} +impl Display for Suttungr { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Kiviuq; +impl Origin for Kiviuq { + fn id(&self) -> NaifId { + NaifId(624i32) + } + fn name(&self) -> &'static str { + "Kiviuq" + } +} +impl Display for Kiviuq { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Mundilfari; +impl Origin for Mundilfari { + fn id(&self) -> NaifId { + NaifId(625i32) + } + fn name(&self) -> &'static str { + "Mundilfari" + } +} +impl Display for Mundilfari { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Albiorix; +impl Origin for Albiorix { + fn id(&self) -> NaifId { + NaifId(626i32) + } + fn name(&self) -> &'static str { + "Albiorix" + } +} +impl Display for Albiorix { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Skathi; +impl Origin for Skathi { + fn id(&self) -> NaifId { + NaifId(627i32) + } + fn name(&self) -> &'static str { + "Skathi" + } +} +impl Display for Skathi { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Erriapus; +impl Origin for Erriapus { + fn id(&self) -> NaifId { + NaifId(628i32) + } + fn name(&self) -> &'static str { + "Erriapus" + } +} +impl Display for Erriapus { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Siarnaq; +impl Origin for Siarnaq { + fn id(&self) -> NaifId { + NaifId(629i32) + } + fn name(&self) -> &'static str { + "Siarnaq" + } +} +impl Display for Siarnaq { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Thrymr; +impl Origin for Thrymr { + fn id(&self) -> NaifId { + NaifId(630i32) + } + fn name(&self) -> &'static str { + "Thrymr" + } +} +impl Display for Thrymr { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Narvi; +impl Origin for Narvi { + fn id(&self) -> NaifId { + NaifId(631i32) + } + fn name(&self) -> &'static str { + "Narvi" + } +} +impl Display for Narvi { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Methone; +impl Origin for Methone { + fn id(&self) -> NaifId { + NaifId(632i32) + } + fn name(&self) -> &'static str { + "Methone" + } +} +impl Display for Methone { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Methone { + fn mean_radius(&self) -> f64 { + 1.45f64 + } +} +impl TriaxialEllipsoid for Methone { + fn radii(&self) -> Radii { + (1.94f64, 1.29f64, 1.21f64) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Pallene; +impl Origin for Pallene { + fn id(&self) -> NaifId { + NaifId(633i32) + } + fn name(&self) -> &'static str { + "Pallene" + } +} +impl Display for Pallene { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Pallene { + fn mean_radius(&self) -> f64 { + 2.23f64 + } +} +impl TriaxialEllipsoid for Pallene { + fn radii(&self) -> Radii { + (2.88f64, 2.08f64, 1.8f64) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Polydeuces; +impl Origin for Polydeuces { + fn id(&self) -> NaifId { + NaifId(634i32) + } + fn name(&self) -> &'static str { + "Polydeuces" + } +} +impl Display for Polydeuces { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Polydeuces { + fn mean_radius(&self) -> f64 { + 1.3f64 + } +} +impl TriaxialEllipsoid for Polydeuces { + fn radii(&self) -> Radii { + (1.5f64, 1.2f64, 1f64) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Daphnis; +impl Origin for Daphnis { + fn id(&self) -> NaifId { + NaifId(635i32) + } + fn name(&self) -> &'static str { + "Daphnis" + } +} +impl Display for Daphnis { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Daphnis { + fn mean_radius(&self) -> f64 { + 3.8f64 + } +} +impl TriaxialEllipsoid for Daphnis { + fn radii(&self) -> Radii { + (4.6f64, 4.5f64, 2.8f64) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Aegir; +impl Origin for Aegir { + fn id(&self) -> NaifId { + NaifId(636i32) + } + fn name(&self) -> &'static str { + "Aegir" + } +} +impl Display for Aegir { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Bebhionn; +impl Origin for Bebhionn { + fn id(&self) -> NaifId { + NaifId(637i32) + } + fn name(&self) -> &'static str { + "Bebhionn" + } +} +impl Display for Bebhionn { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Bergelmir; +impl Origin for Bergelmir { + fn id(&self) -> NaifId { + NaifId(638i32) + } + fn name(&self) -> &'static str { + "Bergelmir" + } +} +impl Display for Bergelmir { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Bestla; +impl Origin for Bestla { + fn id(&self) -> NaifId { + NaifId(639i32) + } + fn name(&self) -> &'static str { + "Bestla" + } +} +impl Display for Bestla { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Farbauti; +impl Origin for Farbauti { + fn id(&self) -> NaifId { + NaifId(640i32) + } + fn name(&self) -> &'static str { + "Farbauti" + } +} +impl Display for Farbauti { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Fenrir; +impl Origin for Fenrir { + fn id(&self) -> NaifId { + NaifId(641i32) + } + fn name(&self) -> &'static str { + "Fenrir" + } +} +impl Display for Fenrir { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Fornjot; +impl Origin for Fornjot { + fn id(&self) -> NaifId { + NaifId(642i32) + } + fn name(&self) -> &'static str { + "Fornjot" + } +} +impl Display for Fornjot { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Hati; +impl Origin for Hati { + fn id(&self) -> NaifId { + NaifId(643i32) + } + fn name(&self) -> &'static str { + "Hati" + } +} +impl Display for Hati { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Hyrrokkin; +impl Origin for Hyrrokkin { + fn id(&self) -> NaifId { + NaifId(644i32) + } + fn name(&self) -> &'static str { + "Hyrrokkin" + } +} +impl Display for Hyrrokkin { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Kari; +impl Origin for Kari { + fn id(&self) -> NaifId { + NaifId(645i32) + } + fn name(&self) -> &'static str { + "Kari" + } +} +impl Display for Kari { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Loge; +impl Origin for Loge { + fn id(&self) -> NaifId { + NaifId(646i32) + } + fn name(&self) -> &'static str { + "Loge" + } +} +impl Display for Loge { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Skoll; +impl Origin for Skoll { + fn id(&self) -> NaifId { + NaifId(647i32) + } + fn name(&self) -> &'static str { + "Skoll" + } +} +impl Display for Skoll { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Surtur; +impl Origin for Surtur { + fn id(&self) -> NaifId { + NaifId(648i32) + } + fn name(&self) -> &'static str { + "Surtur" + } +} +impl Display for Surtur { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Anthe; +impl Origin for Anthe { + fn id(&self) -> NaifId { + NaifId(649i32) + } + fn name(&self) -> &'static str { + "Anthe" + } +} +impl Display for Anthe { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Anthe { + fn mean_radius(&self) -> f64 { + 0.5f64 + } +} +impl TriaxialEllipsoid for Anthe { + fn radii(&self) -> Radii { + (0.5f64, 0.5f64, 0.5f64) + } +} +impl Spheroid for Anthe {} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Jarnsaxa; +impl Origin for Jarnsaxa { + fn id(&self) -> NaifId { + NaifId(650i32) + } + fn name(&self) -> &'static str { + "Jarnsaxa" + } +} +impl Display for Jarnsaxa { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Greip; +impl Origin for Greip { + fn id(&self) -> NaifId { + NaifId(651i32) + } + fn name(&self) -> &'static str { + "Greip" + } +} +impl Display for Greip { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Tarqeq; +impl Origin for Tarqeq { + fn id(&self) -> NaifId { + NaifId(652i32) + } + fn name(&self) -> &'static str { + "Tarqeq" + } +} +impl Display for Tarqeq { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Aegaeon; +impl Origin for Aegaeon { + fn id(&self) -> NaifId { + NaifId(653i32) + } + fn name(&self) -> &'static str { + "Aegaeon" + } +} +impl Display for Aegaeon { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Aegaeon { + fn mean_radius(&self) -> f64 { + 0.33f64 + } +} +impl TriaxialEllipsoid for Aegaeon { + fn radii(&self) -> Radii { + (0.7f64, 0.25f64, 0.2f64) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Ariel; +impl Origin for Ariel { + fn id(&self) -> NaifId { + NaifId(701i32) + } + fn name(&self) -> &'static str { + "Ariel" + } +} +impl Display for Ariel { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Ariel { + fn gravitational_parameter(&self) -> f64 { + 83.46344431770477f64 + } +} +impl MeanRadius for Ariel { + fn mean_radius(&self) -> f64 { + 578.9f64 + } +} +impl TriaxialEllipsoid for Ariel { + fn radii(&self) -> Radii { + (581.1f64, 577.9f64, 577.7f64) + } +} +const RIGHT_ASCENSION_ARIEL: RotationalElement<13usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.493001093409003f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.005061454830783556f64, + ]), +}; +const DECLINATION_ARIEL: RotationalElement<13usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -0.26354471705114374f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.004886921905584123f64, + ]), +}; +const ROTATION_ARIEL: RotationalElement<13usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 2.7265533574655416f64, + c1: -2.492952697630833f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.0008726646259971648f64, + 0.0013962634015954637f64, + ]), +}; +impl RotationalElements for Ariel { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_ARIEL.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_ARIEL.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_ARIEL.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_ARIEL.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_ARIEL.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_ARIEL.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Umbriel; +impl Origin for Umbriel { + fn id(&self) -> NaifId { + NaifId(702i32) + } + fn name(&self) -> &'static str { + "Umbriel" + } +} +impl Display for Umbriel { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Umbriel { + fn gravitational_parameter(&self) -> f64 { + 85.09338094489388f64 + } +} +impl MeanRadius for Umbriel { + fn mean_radius(&self) -> f64 { + 584.7f64 + } +} +impl TriaxialEllipsoid for Umbriel { + fn radii(&self) -> Radii { + (584.7f64, 584.7f64, 584.7f64) + } +} +impl Spheroid for Umbriel {} +const RIGHT_ASCENSION_UMBRIEL: RotationalElement<14usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.493001093409003f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.003665191429188092f64, + ]), +}; +const DECLINATION_UMBRIEL: RotationalElement<14usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -0.26354471705114374f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.003490658503988659f64, + ]), +}; +const ROTATION_UMBRIEL: RotationalElement<14usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 1.885828256779873f64, + c1: -1.5161481881953498f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.0015707963267948964f64, + 0f64, + 0.0010471975511965976f64, + ]), +}; +impl RotationalElements for Umbriel { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_UMBRIEL.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_UMBRIEL.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_UMBRIEL.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_UMBRIEL.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_UMBRIEL.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_UMBRIEL.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Titania; +impl Origin for Titania { + fn id(&self) -> NaifId { + NaifId(703i32) + } + fn name(&self) -> &'static str { + "Titania" + } +} +impl Display for Titania { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Titania { + fn gravitational_parameter(&self) -> f64 { + 226.9437003741248f64 + } +} +impl MeanRadius for Titania { + fn mean_radius(&self) -> f64 { + 788.9f64 + } +} +impl TriaxialEllipsoid for Titania { + fn radii(&self) -> Radii { + (788.9f64, 788.9f64, 788.9f64) + } +} +impl Spheroid for Titania {} +const RIGHT_ASCENSION_TITANIA: RotationalElement<15usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.493001093409003f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.005061454830783556f64, + ]), +}; +const DECLINATION_TITANIA: RotationalElement<15usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -0.26354471705114374f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.004886921905584123f64, + ]), +}; +const ROTATION_TITANIA: RotationalElement<15usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 1.3568189605003917f64, + c1: -0.7217186318332268f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.0013962634015954637f64, + ]), +}; +impl RotationalElements for Titania { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_TITANIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_TITANIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_TITANIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_TITANIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_TITANIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_TITANIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Oberon; +impl Origin for Oberon { + fn id(&self) -> NaifId { + NaifId(704i32) + } + fn name(&self) -> &'static str { + "Oberon" + } +} +impl Display for Oberon { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Oberon { + fn gravitational_parameter(&self) -> f64 { + 205.3234302535623f64 + } +} +impl MeanRadius for Oberon { + fn mean_radius(&self) -> f64 { + 761.4f64 + } +} +impl TriaxialEllipsoid for Oberon { + fn radii(&self) -> Radii { + (761.4f64, 761.4f64, 761.4f64) + } +} +impl Spheroid for Oberon {} +const RIGHT_ASCENSION_OBERON: RotationalElement<16usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.493001093409003f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.0027925268031909274f64, + ]), +}; +const DECLINATION_OBERON: RotationalElement<16usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -0.26354471705114374f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.0027925268031909274f64, + ]), +}; +const ROTATION_OBERON: RotationalElement<16usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 0.1181587903600161f64, + c1: -0.4666921966546346f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.0006981317007977319f64, + ]), +}; +impl RotationalElements for Oberon { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_OBERON.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_OBERON.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_OBERON.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_OBERON.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_OBERON.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_OBERON.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Miranda; +impl Origin for Miranda { + fn id(&self) -> NaifId { + NaifId(705i32) + } + fn name(&self) -> &'static str { + "Miranda" + } +} +impl Display for Miranda { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Miranda { + fn gravitational_parameter(&self) -> f64 { + 4.3195168992321f64 + } +} +impl MeanRadius for Miranda { + fn mean_radius(&self) -> f64 { + 235.8f64 + } +} +impl TriaxialEllipsoid for Miranda { + fn radii(&self) -> Radii { + (240.4f64, 234.2f64, 232.9f64) + } +} +const RIGHT_ASCENSION_MIRANDA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.493001093409003f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.07696902001294993f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.0006981317007977319f64, + 0f64, + ]), +}; +const DECLINATION_MIRANDA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -0.2631956512007449f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.07417649320975901f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.00034906585039886593f64, + 0f64, + ]), +}; +const ROTATION_MIRANDA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 0.5358160803622591f64, + c1: -4.445191100713563f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.02007128639793479f64, + -0.022165681500327987f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.0015707963267948964f64, + 0.002617993877991494f64, + ]), +}; +impl RotationalElements for Miranda { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_MIRANDA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_MIRANDA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_MIRANDA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_MIRANDA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_MIRANDA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_MIRANDA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Cordelia; +impl Origin for Cordelia { + fn id(&self) -> NaifId { + NaifId(706i32) + } + fn name(&self) -> &'static str { + "Cordelia" + } +} +impl Display for Cordelia { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Cordelia { + fn mean_radius(&self) -> f64 { + 13f64 + } +} +impl TriaxialEllipsoid for Cordelia { + fn radii(&self) -> Radii { + (13f64, 13f64, 13f64) + } +} +impl Spheroid for Cordelia {} +const RIGHT_ASCENSION_CORDELIA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.49090669830661f64, + c1: 0f64, + c2: 0f64, + c: Some([ + -0.002617993877991494f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_CORDELIA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -0.2649409804527392f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0.0024434609527920616f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_CORDELIA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 2.2286109218715593f64, + c1: -18.753921879266084f64, + c2: 0f64, + c: Some([ + -0.0006981317007977319f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Cordelia { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_CORDELIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_CORDELIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_CORDELIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_CORDELIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_CORDELIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_CORDELIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Ophelia; +impl Origin for Ophelia { + fn id(&self) -> NaifId { + NaifId(707i32) + } + fn name(&self) -> &'static str { + "Ophelia" + } +} +impl Display for Ophelia { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Ophelia { + fn mean_radius(&self) -> f64 { + 15f64 + } +} +impl TriaxialEllipsoid for Ophelia { + fn radii(&self) -> Radii { + (15f64, 15f64, 15f64) + } +} +impl Spheroid for Ophelia {} +const RIGHT_ASCENSION_OPHELIA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.49090669830661f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + -0.0015707963267948964f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_OPHELIA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -0.2649409804527392f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0.0015707963267948964f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_OPHELIA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 2.2750366799746087f64, + c1: -16.692447910262292f64, + c2: 0f64, + c: Some([ + 0f64, + -0.0005235987755982988f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Ophelia { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_OPHELIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_OPHELIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_OPHELIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_OPHELIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_OPHELIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_OPHELIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Bianca; +impl Origin for Bianca { + fn id(&self) -> NaifId { + NaifId(708i32) + } + fn name(&self) -> &'static str { + "Bianca" + } +} +impl Display for Bianca { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Bianca { + fn mean_radius(&self) -> f64 { + 21f64 + } +} +impl TriaxialEllipsoid for Bianca { + fn radii(&self) -> Radii { + (21f64, 21f64, 21f64) + } +} +impl Spheroid for Bianca {} +const RIGHT_ASCENSION_BIANCA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.49090669830661f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + -0.0027925268031909274f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_BIANCA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -0.2649409804527392f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0.0027925268031909274f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_BIANCA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 1.8406242291532198f64, + c1: -14.458158751655587f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + -0.0006981317007977319f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Bianca { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_BIANCA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_BIANCA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_BIANCA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_BIANCA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_BIANCA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_BIANCA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Cressida; +impl Origin for Cressida { + fn id(&self) -> NaifId { + NaifId(709i32) + } + fn name(&self) -> &'static str { + "Cressida" + } +} +impl Display for Cressida { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Cressida { + fn mean_radius(&self) -> f64 { + 31f64 + } +} +impl TriaxialEllipsoid for Cressida { + fn radii(&self) -> Radii { + (31f64, 31f64, 31f64) + } +} +impl Spheroid for Cressida {} +const RIGHT_ASCENSION_CRESSIDA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.49090669830661f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + -0.0006981317007977319f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_CRESSIDA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -0.2649409804527392f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0.0006981317007977319f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_CRESSIDA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 1.0325367854798453f64, + c1: -13.553906388910956f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + -0.00017453292519943296f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Cressida { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_CRESSIDA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_CRESSIDA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_CRESSIDA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_CRESSIDA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_CRESSIDA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_CRESSIDA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Desdemona; +impl Origin for Desdemona { + fn id(&self) -> NaifId { + NaifId(710i32) + } + fn name(&self) -> &'static str { + "Desdemona" + } +} +impl Display for Desdemona { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Desdemona { + fn mean_radius(&self) -> f64 { + 27f64 + } +} +impl TriaxialEllipsoid for Desdemona { + fn radii(&self) -> Radii { + (27f64, 27f64, 27f64) + } +} +impl Spheroid for Desdemona {} +const RIGHT_ASCENSION_DESDEMONA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.49090669830661f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + -0.0029670597283903604f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_DESDEMONA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -0.2649409804527392f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0.0027925268031909274f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_DESDEMONA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 1.6594590527962085f64, + c1: -13.265430289266899f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + -0.0006981317007977319f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Desdemona { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_DESDEMONA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_DESDEMONA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_DESDEMONA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_DESDEMONA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_DESDEMONA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_DESDEMONA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Juliet; +impl Origin for Juliet { + fn id(&self) -> NaifId { + NaifId(711i32) + } + fn name(&self) -> &'static str { + "Juliet" + } +} +impl Display for Juliet { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Juliet { + fn mean_radius(&self) -> f64 { + 42f64 + } +} +impl TriaxialEllipsoid for Juliet { + fn radii(&self) -> Radii { + (42f64, 42f64, 42f64) + } +} +impl Spheroid for Juliet {} +const RIGHT_ASCENSION_JULIET: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.49090669830661f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.0010471975511965976f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_JULIET: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -0.2649409804527392f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.0010471975511965976f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_JULIET: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 5.2806681848340435f64, + c1: -12.74309158902866f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.00034906585039886593f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Juliet { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_JULIET.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_JULIET.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_JULIET.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_JULIET.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_JULIET.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_JULIET.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Portia; +impl Origin for Portia { + fn id(&self) -> NaifId { + NaifId(712i32) + } + fn name(&self) -> &'static str { + "Portia" + } +} +impl Display for Portia { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Portia { + fn mean_radius(&self) -> f64 { + 54f64 + } +} +impl TriaxialEllipsoid for Portia { + fn radii(&self) -> Radii { + (54f64, 54f64, 54f64) + } +} +impl Spheroid for Portia {} +const RIGHT_ASCENSION_PORTIA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.49090669830661f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.0015707963267948964f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_PORTIA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -0.2649409804527392f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.0015707963267948964f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_PORTIA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 0.4368559117741807f64, + c1: -12.243250601727652f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.00034906585039886593f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Portia { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PORTIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_PORTIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_PORTIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PORTIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_PORTIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_PORTIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Rosalind; +impl Origin for Rosalind { + fn id(&self) -> NaifId { + NaifId(713i32) + } + fn name(&self) -> &'static str { + "Rosalind" + } +} +impl Display for Rosalind { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Rosalind { + fn mean_radius(&self) -> f64 { + 27f64 + } +} +impl TriaxialEllipsoid for Rosalind { + fn radii(&self) -> Radii { + (27f64, 27f64, 27f64) + } +} +impl Spheroid for Rosalind {} +const RIGHT_ASCENSION_ROSALIND: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.49090669830661f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.005061454830783556f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_ROSALIND: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -0.2649409804527392f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.004886921905584123f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_ROSALIND: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 5.496041814530144f64, + c1: -11.250935609538423f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.0013962634015954637f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Rosalind { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_ROSALIND.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_ROSALIND.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_ROSALIND.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_ROSALIND.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_ROSALIND.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_ROSALIND.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Belinda; +impl Origin for Belinda { + fn id(&self) -> NaifId { + NaifId(714i32) + } + fn name(&self) -> &'static str { + "Belinda" + } +} +impl Display for Belinda { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Belinda { + fn mean_radius(&self) -> f64 { + 33f64 + } +} +impl TriaxialEllipsoid for Belinda { + fn radii(&self) -> Radii { + (33f64, 33f64, 33f64) + } +} +impl Spheroid for Belinda {} +const RIGHT_ASCENSION_BELINDA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.49090669830661f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.0005235987755982988f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_BELINDA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -0.2649409804527392f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.0005235987755982988f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_BELINDA: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 5.191656392982332f64, + c1: -10.076882135239488f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.00017453292519943296f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Belinda { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_BELINDA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_BELINDA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_BELINDA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_BELINDA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_BELINDA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_BELINDA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Puck; +impl Origin for Puck { + fn id(&self) -> NaifId { + NaifId(715i32) + } + fn name(&self) -> &'static str { + "Puck" + } +} +impl Display for Puck { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Puck { + fn mean_radius(&self) -> f64 { + 77f64 + } +} +impl TriaxialEllipsoid for Puck { + fn radii(&self) -> Radii { + (77f64, 77f64, 77f64) + } +} +impl Spheroid for Puck {} +const RIGHT_ASCENSION_PUCK: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.49090669830661f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.005759586531581287f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_PUCK: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -0.2649409804527392f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.0054105206811824215f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_PUCK: RotationalElement<18usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 1.5924384095196262f64, + c1: -8.247467318113788f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.0015707963267948964f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Puck { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PUCK.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_PUCK.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_PUCK.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PUCK.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_PUCK.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_PUCK.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Caliban; +impl Origin for Caliban { + fn id(&self) -> NaifId { + NaifId(716i32) + } + fn name(&self) -> &'static str { + "Caliban" + } +} +impl Display for Caliban { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Sycorax; +impl Origin for Sycorax { + fn id(&self) -> NaifId { + NaifId(717i32) + } + fn name(&self) -> &'static str { + "Sycorax" + } +} +impl Display for Sycorax { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Prospero; +impl Origin for Prospero { + fn id(&self) -> NaifId { + NaifId(718i32) + } + fn name(&self) -> &'static str { + "Prospero" + } +} +impl Display for Prospero { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Setebos; +impl Origin for Setebos { + fn id(&self) -> NaifId { + NaifId(719i32) + } + fn name(&self) -> &'static str { + "Setebos" + } +} +impl Display for Setebos { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Stephano; +impl Origin for Stephano { + fn id(&self) -> NaifId { + NaifId(720i32) + } + fn name(&self) -> &'static str { + "Stephano" + } +} +impl Display for Stephano { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Trinculo; +impl Origin for Trinculo { + fn id(&self) -> NaifId { + NaifId(721i32) + } + fn name(&self) -> &'static str { + "Trinculo" + } +} +impl Display for Trinculo { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Francisco; +impl Origin for Francisco { + fn id(&self) -> NaifId { + NaifId(722i32) + } + fn name(&self) -> &'static str { + "Francisco" + } +} +impl Display for Francisco { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Margaret; +impl Origin for Margaret { + fn id(&self) -> NaifId { + NaifId(723i32) + } + fn name(&self) -> &'static str { + "Margaret" + } +} +impl Display for Margaret { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Ferdinand; +impl Origin for Ferdinand { + fn id(&self) -> NaifId { + NaifId(724i32) + } + fn name(&self) -> &'static str { + "Ferdinand" + } +} +impl Display for Ferdinand { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Perdita; +impl Origin for Perdita { + fn id(&self) -> NaifId { + NaifId(725i32) + } + fn name(&self) -> &'static str { + "Perdita" + } +} +impl Display for Perdita { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Mab; +impl Origin for Mab { + fn id(&self) -> NaifId { + NaifId(726i32) + } + fn name(&self) -> &'static str { + "Mab" + } +} +impl Display for Mab { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Cupid; +impl Origin for Cupid { + fn id(&self) -> NaifId { + NaifId(727i32) + } + fn name(&self) -> &'static str { + "Cupid" + } +} +impl Display for Cupid { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Triton; +impl Origin for Triton { + fn id(&self) -> NaifId { + NaifId(801i32) + } + fn name(&self) -> &'static str { + "Triton" + } +} +impl Display for Triton { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Triton { + fn gravitational_parameter(&self) -> f64 { + 1428.495462910464f64 + } +} +impl MeanRadius for Triton { + fn mean_radius(&self) -> f64 { + 1352.6f64 + } +} +impl TriaxialEllipsoid for Triton { + fn radii(&self) -> Radii { + (1352.6f64, 1352.6f64, 1352.6f64) + } +} +impl Spheroid for Triton {} +const RIGHT_ASCENSION_TRITON: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 5.224817648770225f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.5646140130201657f64, + 0f64, + -0.1096066770252439f64, + -0.03630284844148206f64, + -0.012915436464758038f64, + -0.004886921905584123f64, + -0.0019198621771937625f64, + -0.0012217304763960308f64, + -0.00034906585039886593f64, + -0.00017453292519943296f64, + ]), +}; +const DECLINATION_TRITON: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 0.7185520530460655f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.3935717463247213f64, + 0f64, + 0.03665191429188092f64, + 0.009599310885968814f64, + 0.0027925268031909274f64, + 0.0008726646259971648f64, + 0.00034906585039886593f64, + 0.00017453292519943296f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_TRITON: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 5.175424830938785f64, + c1: -1.069140942327404f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.3883357585687383f64, + 0f64, + 0.11746065865921838f64, + 0.03577924966588375f64, + 0.012915436464758038f64, + 0.004886921905584123f64, + 0.0019198621771937625f64, + 0.0008726646259971648f64, + 0.00034906585039886593f64, + 0.00017453292519943296f64, + ]), +}; +impl RotationalElements for Triton { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_TRITON.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_TRITON.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_TRITON.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_TRITON.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_TRITON.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_TRITON.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Nereid; +impl Origin for Nereid { + fn id(&self) -> NaifId { + NaifId(802i32) + } + fn name(&self) -> &'static str { + "Nereid" + } +} +impl Display for Nereid { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl MeanRadius for Nereid { + fn mean_radius(&self) -> f64 { + 170f64 + } +} +impl TriaxialEllipsoid for Nereid { + fn radii(&self) -> Radii { + (170f64, 170f64, 170f64) + } +} +impl Spheroid for Nereid {} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Naiad; +impl Origin for Naiad { + fn id(&self) -> NaifId { + NaifId(803i32) + } + fn name(&self) -> &'static str { + "Naiad" + } +} +impl Display for Naiad { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Naiad { + fn gravitational_parameter(&self) -> f64 { + 0.008530281246540886f64 + } +} +impl MeanRadius for Naiad { + fn mean_radius(&self) -> f64 { + 29f64 + } +} +impl TriaxialEllipsoid for Naiad { + fn radii(&self) -> Radii { + (29f64, 29f64, 29f64) + } +} +impl Spheroid for Naiad {} +const RIGHT_ASCENSION_NAIAD: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 5.224817648770225f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0.012217304763960306f64, + -0.11327186845443199f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.004363323129985824f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_NAIAD: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 0.7567747636647413f64, + c1: 0f64, + c2: 0f64, + c: Some([ + -0.00890117918517108f64, + -0.08290313946973066f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.0015707963267948964f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_NAIAD: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 4.434183497616794f64, + c1: 21.342656148360604f64, + c2: 0f64, + c: Some([ + -0.008377580409572781f64, + 0.07679448708775051f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.00471238898038469f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Naiad { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_NAIAD.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_NAIAD.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_NAIAD.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_NAIAD.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_NAIAD.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_NAIAD.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Thalassa; +impl Origin for Thalassa { + fn id(&self) -> NaifId { + NaifId(804i32) + } + fn name(&self) -> &'static str { + "Thalassa" + } +} +impl Display for Thalassa { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Thalassa { + fn gravitational_parameter(&self) -> f64 { + 0.0235887319799217f64 + } +} +impl MeanRadius for Thalassa { + fn mean_radius(&self) -> f64 { + 40f64 + } +} +impl TriaxialEllipsoid for Thalassa { + fn radii(&self) -> Radii { + (40f64, 40f64, 40f64) + } +} +impl Spheroid for Thalassa {} +const RIGHT_ASCENSION_THALASSA: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 5.224817648770225f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0.012217304763960306f64, + 0f64, + -0.004886921905584123f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_THALASSA: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 0.7583455599915362f64, + c1: 0f64, + c2: 0f64, + c: Some([ + -0.00890117918517108f64, + 0f64, + -0.003665191429188092f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_THALASSA: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 1.7812830345854127f64, + c1: 20.171739891174827f64, + c2: 0f64, + c: Some([ + -0.008377580409572781f64, + 0f64, + 0.0033161255787892262f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Thalassa { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_THALASSA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_THALASSA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_THALASSA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_THALASSA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_THALASSA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_THALASSA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Despina; +impl Origin for Despina { + fn id(&self) -> NaifId { + NaifId(805i32) + } + fn name(&self) -> &'static str { + "Despina" + } +} +impl Display for Despina { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Despina { + fn gravitational_parameter(&self) -> f64 { + 0.1167318403814998f64 + } +} +impl MeanRadius for Despina { + fn mean_radius(&self) -> f64 { + 74f64 + } +} +impl TriaxialEllipsoid for Despina { + fn radii(&self) -> Radii { + (74f64, 74f64, 74f64) + } +} +impl Spheroid for Despina {} +const RIGHT_ASCENSION_DESPINA: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 5.224817648770225f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0.012217304763960306f64, + 0f64, + 0f64, + -0.0015707963267948964f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_DESPINA: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 0.7583455599915362f64, + c1: 0f64, + c2: 0f64, + c: Some([ + -0.00890117918517108f64, + 0f64, + 0f64, + -0.0012217304763960308f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_DESPINA: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 5.34960869028782f64, + c1: 18.77510290185297f64, + c2: 0f64, + c: Some([ + -0.008552113334772215f64, + 0f64, + 0f64, + 0.0010471975511965976f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Despina { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_DESPINA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_DESPINA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_DESPINA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_DESPINA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_DESPINA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_DESPINA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Galatea; +impl Origin for Galatea { + fn id(&self) -> NaifId { + NaifId(806i32) + } + fn name(&self) -> &'static str { + "Galatea" + } +} +impl Display for Galatea { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Galatea { + fn gravitational_parameter(&self) -> f64 { + 0.189898503906069f64 + } +} +impl MeanRadius for Galatea { + fn mean_radius(&self) -> f64 { + 79f64 + } +} +impl TriaxialEllipsoid for Galatea { + fn radii(&self) -> Radii { + (79f64, 79f64, 79f64) + } +} +impl Spheroid for Galatea {} +const RIGHT_ASCENSION_GALATEA: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 5.224817648770225f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0.012217304763960306f64, + 0f64, + 0f64, + 0f64, + -0.0012217304763960308f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_GALATEA: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 0.7579964941411373f64, + c1: 0f64, + c2: 0f64, + c: Some([ + -0.00890117918517108f64, + 0f64, + 0f64, + 0f64, + -0.0008726646259971648f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_GALATEA: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 4.504520266472165f64, + c1: 14.6548275586037f64, + c2: 0f64, + c: Some([ + -0.008377580409572781f64, + 0f64, + 0f64, + 0f64, + 0.0008726646259971648f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Galatea { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_GALATEA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_GALATEA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_GALATEA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_GALATEA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_GALATEA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_GALATEA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Larissa; +impl Origin for Larissa { + fn id(&self) -> NaifId { + NaifId(807i32) + } + fn name(&self) -> &'static str { + "Larissa" + } +} +impl Display for Larissa { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Larissa { + fn gravitational_parameter(&self) -> f64 { + 0.2548437405693583f64 + } +} +impl MeanRadius for Larissa { + fn mean_radius(&self) -> f64 { + 96f64 + } +} +impl TriaxialEllipsoid for Larissa { + fn radii(&self) -> Radii { + (96f64, 96f64, 96f64) + } +} +impl Spheroid for Larissa {} +const RIGHT_ASCENSION_LARISSA: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 5.224817648770225f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0.012217304763960306f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.00471238898038469f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_LARISSA: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 0.7576474282907384f64, + c1: 0f64, + c2: 0f64, + c: Some([ + -0.00890117918517108f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.003490658503988659f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_LARISSA: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 3.1312952110030268f64, + c1: 11.328119671568512f64, + c2: 0f64, + c: Some([ + -0.008377580409572781f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.0033161255787892262f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Larissa { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_LARISSA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_LARISSA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_LARISSA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_LARISSA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_LARISSA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_LARISSA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Proteus; +impl Origin for Proteus { + fn id(&self) -> NaifId { + NaifId(808i32) + } + fn name(&self) -> &'static str { + "Proteus" + } +} +impl Display for Proteus { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Proteus { + fn gravitational_parameter(&self) -> f64 { + 2.583422379120727f64 + } +} +impl MeanRadius for Proteus { + fn mean_radius(&self) -> f64 { + 208f64 + } +} +impl TriaxialEllipsoid for Proteus { + fn radii(&self) -> Radii { + (218f64, 208f64, 201f64) + } +} +const RIGHT_ASCENSION_PROTEUS: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 5.22324685244343f64, + c1: 0f64, + c2: 0f64, + c: Some([ + 0.012217304763960306f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.0008726646259971648f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const DECLINATION_PROTEUS: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 0.7489207820307667f64, + c1: 0f64, + c2: 0f64, + c: Some([ + -0.00890117918517108f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + -0.0006981317007977319f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +const ROTATION_PROTEUS: RotationalElement<17usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 1.6297884555123048f64, + c1: 5.598412754411688f64, + c2: 0f64, + c: Some([ + -0.008377580409572781f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.0006981317007977319f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + ]), +}; +impl RotationalElements for Proteus { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PROTEUS.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_PROTEUS.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_PROTEUS.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PROTEUS.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_PROTEUS.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_PROTEUS.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Halimede; +impl Origin for Halimede { + fn id(&self) -> NaifId { + NaifId(809i32) + } + fn name(&self) -> &'static str { + "Halimede" + } +} +impl Display for Halimede { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Psamathe; +impl Origin for Psamathe { + fn id(&self) -> NaifId { + NaifId(810i32) + } + fn name(&self) -> &'static str { + "Psamathe" + } +} +impl Display for Psamathe { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Sao; +impl Origin for Sao { + fn id(&self) -> NaifId { + NaifId(811i32) + } + fn name(&self) -> &'static str { + "Sao" + } +} +impl Display for Sao { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Laomedeia; +impl Origin for Laomedeia { + fn id(&self) -> NaifId { + NaifId(812i32) + } + fn name(&self) -> &'static str { + "Laomedeia" + } +} +impl Display for Laomedeia { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Neso; +impl Origin for Neso { + fn id(&self) -> NaifId { + NaifId(813i32) + } + fn name(&self) -> &'static str { + "Neso" + } +} +impl Display for Neso { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Charon; +impl Origin for Charon { + fn id(&self) -> NaifId { + NaifId(901i32) + } + fn name(&self) -> &'static str { + "Charon" + } +} +impl Display for Charon { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Charon { + fn gravitational_parameter(&self) -> f64 { + 105.8799888601881f64 + } +} +impl MeanRadius for Charon { + fn mean_radius(&self) -> f64 { + 606f64 + } +} +impl TriaxialEllipsoid for Charon { + fn radii(&self) -> Radii { + (606f64, 606f64, 606f64) + } +} +impl Spheroid for Charon {} +const RIGHT_ASCENSION_CHARON: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 2.3211657321048187f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const DECLINATION_CHARON: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -0.10756464180041053f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const ROTATION_CHARON: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 2.1414317257344426f64, + c1: 0.9837115923543857f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Charon { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_CHARON.angle::<0usize>(None, t), + DECLINATION_CHARON.angle::<0usize>(None, t), + ROTATION_CHARON.angle::<0usize>(None, t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_CHARON.angle_dot::<0usize>(None, t), + DECLINATION_CHARON.angle_dot::<0usize>(None, t), + ROTATION_CHARON.angle_dot::<0usize>(None, t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Nix; +impl Origin for Nix { + fn id(&self) -> NaifId { + NaifId(902i32) + } + fn name(&self) -> &'static str { + "Nix" + } +} +impl Display for Nix { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Nix { + fn gravitational_parameter(&self) -> f64 { + 0.00304817564816976f64 + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Hydra; +impl Origin for Hydra { + fn id(&self) -> NaifId { + NaifId(903i32) + } + fn name(&self) -> &'static str { + "Hydra" + } +} +impl Display for Hydra { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Hydra { + fn gravitational_parameter(&self) -> f64 { + 0.003211039206155255f64 + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Kerberos; +impl Origin for Kerberos { + fn id(&self) -> NaifId { + NaifId(904i32) + } + fn name(&self) -> &'static str { + "Kerberos" + } +} +impl Display for Kerberos { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Kerberos { + fn gravitational_parameter(&self) -> f64 { + 0.001110040850536676f64 + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Styx; +impl Origin for Styx { + fn id(&self) -> NaifId { + NaifId(905i32) + } + fn name(&self) -> &'static str { + "Styx" + } +} +impl Display for Styx { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} +impl PointMass for Styx { + fn gravitational_parameter(&self) -> f64 { + 0f64 + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Gaspra; +impl Origin 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 MeanRadius for Gaspra { + fn mean_radius(&self) -> f64 { + 6.1f64 + } +} +impl TriaxialEllipsoid for Gaspra { + fn radii(&self) -> Radii { + (9.1f64, 5.2f64, 4.4f64) + } +} +const RIGHT_ASCENSION_GASPRA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.16528268016386302f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const DECLINATION_GASPRA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 0.46600291028248597f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const ROTATION_GASPRA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 1.4603169851436555f64, + c1: 21.41364504378302f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Gaspra { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_GASPRA.angle::<0usize>(None, t), + DECLINATION_GASPRA.angle::<0usize>(None, t), + ROTATION_GASPRA.angle::<0usize>(None, t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_GASPRA.angle_dot::<0usize>(None, t), + DECLINATION_GASPRA.angle_dot::<0usize>(None, t), + ROTATION_GASPRA.angle_dot::<0usize>(None, t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Ida; +impl Origin 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 MeanRadius for Ida { + fn mean_radius(&self) -> f64 { + 15.65f64 + } +} +impl TriaxialEllipsoid for Ida { + fn radii(&self) -> Radii { + (26.8f64, 12f64, 7.6f64) + } +} +const RIGHT_ASCENSION_IDA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 2.9454176456656302f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const DECLINATION_IDA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -1.5205308443374599f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const ROTATION_IDA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 4.78307481509046f64, + c1: 32.54389804704987f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Ida { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_IDA.angle::<0usize>(None, t), + DECLINATION_IDA.angle::<0usize>(None, t), + ROTATION_IDA.angle::<0usize>(None, t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_IDA.angle_dot::<0usize>(None, t), + DECLINATION_IDA.angle_dot::<0usize>(None, t), + ROTATION_IDA.angle_dot::<0usize>(None, t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Dactyl; +impl Origin 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()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Ceres; +impl Origin 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 PointMass for Ceres { + fn gravitational_parameter(&self) -> f64 { + 62.62888864440993f64 + } +} +impl MeanRadius for Ceres { + fn mean_radius(&self) -> f64 { + 470f64 + } +} +impl TriaxialEllipsoid for Ceres { + fn radii(&self) -> Radii { + (487.3f64, 487.3f64, 446f64) + } +} +impl Spheroid for Ceres {} +const RIGHT_ASCENSION_CERES: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 5.0862035995768355f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const DECLINATION_CERES: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.165251621801494f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const ROTATION_CERES: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 2.9784043685283237f64, + c1: 16.618208323400072f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Ceres { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_CERES.angle::<0usize>(None, t), + DECLINATION_CERES.angle::<0usize>(None, t), + ROTATION_CERES.angle::<0usize>(None, t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_CERES.angle_dot::<0usize>(None, t), + DECLINATION_CERES.angle_dot::<0usize>(None, t), + ROTATION_CERES.angle_dot::<0usize>(None, t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Pallas; +impl Origin 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 + } +} +const RIGHT_ASCENSION_PALLAS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.5759586531581288f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const DECLINATION_PALLAS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -0.05235987755982989f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const ROTATION_PALLAS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 0.6632251157578453f64, + c1: 19.299913700406368f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Pallas { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PALLAS.angle::<0usize>(None, t), + DECLINATION_PALLAS.angle::<0usize>(None, t), + ROTATION_PALLAS.angle::<0usize>(None, t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_PALLAS.angle_dot::<0usize>(None, t), + DECLINATION_PALLAS.angle_dot::<0usize>(None, t), + ROTATION_PALLAS.angle_dot::<0usize>(None, t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Vesta; +impl Origin 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 PointMass for Vesta { + fn gravitational_parameter(&self) -> f64 { + 17.288232879171513f64 + } +} +impl TriaxialEllipsoid for Vesta { + fn radii(&self) -> Radii { + (289f64, 280f64, 229f64) + } +} +const RIGHT_ASCENSION_VESTA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 5.393608440730596f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const DECLINATION_VESTA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 0.7371398095798051f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const ROTATION_VESTA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 4.980995152266617f64, + c1: 28.22778495282912f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Vesta { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_VESTA.angle::<0usize>(None, t), + DECLINATION_VESTA.angle::<0usize>(None, t), + ROTATION_VESTA.angle::<0usize>(None, t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_VESTA.angle_dot::<0usize>(None, t), + DECLINATION_VESTA.angle_dot::<0usize>(None, t), + ROTATION_VESTA.angle_dot::<0usize>(None, t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Psyche; +impl Origin 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 PointMass for Psyche { + fn gravitational_parameter(&self) -> f64 { + 1.5896582441709424f64 + } +} +impl MeanRadius for Psyche { + fn mean_radius(&self) -> f64 { + 113f64 + } +} +impl TriaxialEllipsoid for Psyche { + fn radii(&self) -> Radii { + (139.5f64, 116f64, 94.5f64) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Lutetia; +impl Origin 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 MeanRadius for Lutetia { + fn mean_radius(&self) -> f64 { + 52.5f64 + } +} +impl TriaxialEllipsoid for Lutetia { + fn radii(&self) -> Radii { + (62f64, 50.5f64, 46.5f64) + } +} +const RIGHT_ASCENSION_LUTETIA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.9075712110370514f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const DECLINATION_LUTETIA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 0.20943951023931956f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const ROTATION_LUTETIA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 1.6406094968746698f64, + c1: 18.4612463429088f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Lutetia { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_LUTETIA.angle::<0usize>(None, t), + DECLINATION_LUTETIA.angle::<0usize>(None, t), + ROTATION_LUTETIA.angle::<0usize>(None, t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_LUTETIA.angle_dot::<0usize>(None, t), + DECLINATION_LUTETIA.angle_dot::<0usize>(None, t), + ROTATION_LUTETIA.angle_dot::<0usize>(None, t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Kleopatra; +impl Origin 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()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Eros; +impl Origin 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 PointMass for Eros { + fn gravitational_parameter(&self) -> f64 { + 0.0004463f64 + } +} +impl MeanRadius for Eros { + fn mean_radius(&self) -> f64 { + 8.45f64 + } +} +impl TriaxialEllipsoid for Eros { + fn radii(&self) -> Radii { + (17f64, 5.5f64, 5.5f64) + } +} +const RIGHT_ASCENSION_EROS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 0.1980948701013564f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const DECLINATION_EROS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 0.30054569719342356f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const ROTATION_EROS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 5.690995091977911f64, + c1: 28.612729617819042f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Eros { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_EROS.angle::<0usize>(None, t), + DECLINATION_EROS.angle::<0usize>(None, t), + ROTATION_EROS.angle::<0usize>(None, t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_EROS.angle_dot::<0usize>(None, t), + DECLINATION_EROS.angle_dot::<0usize>(None, t), + ROTATION_EROS.angle_dot::<0usize>(None, t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Davida; +impl Origin 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 PointMass for Davida { + fn gravitational_parameter(&self) -> f64 { + 3.8944831481705644f64 + } +} +impl MeanRadius for Davida { + fn mean_radius(&self) -> f64 { + 150f64 + } +} +impl TriaxialEllipsoid for Davida { + fn radii(&self) -> Radii { + (180f64, 147f64, 127f64) + } +} +const RIGHT_ASCENSION_DAVIDA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 5.183627878423159f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const DECLINATION_DAVIDA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 0.08726646259971647f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const ROTATION_DAVIDA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 4.679227724596798f64, + c1: 29.39866372732388f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Davida { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_DAVIDA.angle::<0usize>(None, t), + DECLINATION_DAVIDA.angle::<0usize>(None, t), + ROTATION_DAVIDA.angle::<0usize>(None, t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_DAVIDA.angle_dot::<0usize>(None, t), + DECLINATION_DAVIDA.angle_dot::<0usize>(None, t), + ROTATION_DAVIDA.angle_dot::<0usize>(None, t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Mathilde; +impl Origin 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 MeanRadius for Mathilde { + fn mean_radius(&self) -> f64 { + 26.5f64 + } +} +impl TriaxialEllipsoid for Mathilde { + fn radii(&self) -> Radii { + (33f64, 24f64, 23f64) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Steins; +impl Origin 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 MeanRadius for Steins { + fn mean_radius(&self) -> f64 { + 2.7f64 + } +} +impl TriaxialEllipsoid for Steins { + fn radii(&self) -> Radii { + (3.24f64, 2.73f64, 2.04f64) + } +} +const RIGHT_ASCENSION_STEINS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 1.5882496193148399f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const DECLINATION_STEINS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -1.0821041362364843f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const ROTATION_STEINS: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 5.615771401216954f64, + c1: 24.925032561498227f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Steins { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_STEINS.angle::<0usize>(None, t), + DECLINATION_STEINS.angle::<0usize>(None, t), + ROTATION_STEINS.angle::<0usize>(None, t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_STEINS.angle_dot::<0usize>(None, t), + DECLINATION_STEINS.angle_dot::<0usize>(None, t), + ROTATION_STEINS.angle_dot::<0usize>(None, t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Braille; +impl Origin 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()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct WilsonHarrington; +impl Origin 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()) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Toutatis; +impl Origin 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 TriaxialEllipsoid for Toutatis { + fn radii(&self) -> Radii { + (2.13f64, 1.015f64, 0.85f64) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Itokawa; +impl Origin 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 TriaxialEllipsoid for Itokawa { + fn radii(&self) -> Radii { + (0.268f64, 0.147f64, 0.104f64) + } +} +const RIGHT_ASCENSION_ITOKAWA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 1.5800465718304666f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const DECLINATION_ITOKAWA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Declination, + c0: -1.1571532940722404f64, + c1: 0f64, + c2: 0f64, + c: None, +}; +const ROTATION_ITOKAWA: RotationalElement<0usize> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 0f64, + c1: 12.429240095029979f64, + c2: 0f64, + c: None, +}; +impl RotationalElements for Itokawa { + fn rotational_elements(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_ITOKAWA.angle::<0usize>(None, t), + DECLINATION_ITOKAWA.angle::<0usize>(None, t), + ROTATION_ITOKAWA.angle::<0usize>(None, t), + ) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + ( + RIGHT_ASCENSION_ITOKAWA.angle_dot::<0usize>(None, t), + DECLINATION_ITOKAWA.angle_dot::<0usize>(None, t), + ROTATION_ITOKAWA.angle_dot::<0usize>(None, t), + ) + } +} +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub struct Bennu; +impl Origin 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()) + } +} +const NUTATION_PRECESSION_MERCURY: NutationPrecessionCoefficients<5usize> = + NutationPrecessionCoefficients { + theta0: [ + 3.0506799486005773f64, + 6.101359897201155f64, + 2.868854538622146f64, + 5.919534488968053f64, + 2.6870291303890443f64, + ], + theta1: [ + 2608.7878923240937f64, + 5217.575784648187f64, + 7826.363676972282f64, + 10435.151569296375f64, + 13043.939461620466f64, + ], + }; +const NUTATION_PRECESSION_EARTH: NutationPrecessionCoefficients<13usize> = + NutationPrecessionCoefficients { + theta0: [ + 2.1824469631563095f64, + 4.364876473020098f64, + 4.537995681525416f64, + 3.0826877913349846f64, + 6.240058221362807f64, + 5.438253962996612f64, + 2.355548718369107f64, + 4.827877416989155f64, + 0.5973563897875792f64, + 0.2641381289968218f64, + 2.0899096062155698f64, + 4.188109526378113f64, + 0.4372573375021394f64, + ], + theta1: [ + -33.781483888495835f64, + -67.56296777699167f64, + 8294.909972626925f64, + 8504.459388212737f64, + 628.3019668015924f64, + 16833.15084472816f64, + 8328.69145651542f64, + 209.54947933396397f64, + 1114.6285779726247f64, + -101.3444516654875f64, + 2.301053255936537f64, + 104.77473966698199f64, + 8261.12848873843f64, + ], + }; +const NUTATION_PRECESSION_MARS: NutationPrecessionCoefficients<26usize> = + NutationPrecessionCoefficients { + theta0: [ + 3.328804809897935f64, + 0.37470342287773584f64, + 5.809517398292802f64, + 6.892873571600945f64, + 3.3097152567180146f64, + 2.120032883264378f64, + 4.032588225058434f64, + 4.387288948439982f64, + 3.8045796985836846f64, + 3.424288764152381f64, + 3.4730520762801462f64, + 3.9495523217086292f64, + 4.357448194643978f64, + 4.645778664015252f64, + 1.3857704297725961f64, + 2.136869016190709f64, + 0.751510868094019f64, + 1.0064158213753553f64, + 1.3871248750853138f64, + 2.9029314796567682f64, + 2.252727410236719f64, + 0.6344650043848296f64, + 0.9890544553471146f64, + 1.1757236496733376f64, + 1.8289772979888115f64, + 1.664898441223219f64, + ], + theta1: [ + 277.80594525842264f64, + 555.6129894920322f64, + 334.05422022489097f64, + 668.125936040531f64, + 719340.2120445863f64, + 11.523153020184504f64, + 11.536473384554899f64, + 23.047098122619843f64, + 668.1113614443373f64, + 334.05316148477937f64, + 334.0469780000094f64, + 668.1268926511307f64, + 1002.1807129125305f64, + 1336.235189496269f64, + 0.008801023466045386f64, + 334.054984682245f64, + 668.1273150051017f64, + 1002.1811764929237f64, + 1336.2354112473317f64, + 0.008801023466045386f64, + 334.05659172556966f64, + 668.130317528175f64, + 1002.1842799588599f64, + 1336.2285297823557f64, + 1670.2877519268022f64, + 0.008801023466045386f64, + ], + }; +const NUTATION_PRECESSION_JUPITER: NutationPrecessionCoefficients<15usize> = + NutationPrecessionCoefficients { + theta0: [ + 1.2796754075622423f64, + 0.42970006184100396f64, + 4.9549897464119015f64, + 6.2098814785958245f64, + 2.092649773141201f64, + 4.010766621082969f64, + 6.147922290150026f64, + 1.9783307071355725f64, + 2.5593508151244846f64, + 0.8594001236820079f64, + 1.734171606432425f64, + 3.0699533280603655f64, + 5.241627996900319f64, + 1.9898901100379935f64, + 0.864134346731335f64, + ], + theta1: [ + 1596.503281347521f64, + 787.7927551311844f64, + 84.66068602648895f64, + 20.792107379008446f64, + 4.574507969477138f64, + 1.1222467090323538f64, + 41.58421475801689f64, + 105.9414855960558f64, + 3193.006562695042f64, + 1575.5855102623689f64, + 84.65553032387855f64, + 20.80363527871787f64, + 4.582318317879813f64, + 105.94580703128374f64, + 1.1222467090323538f64, + ], + }; +const NUTATION_PRECESSION_SATURN: NutationPrecessionCoefficients<8usize> = + NutationPrecessionCoefficients { + theta0: [ + 6.166597313146365f64, + 0.5012585611727715f64, + 3.0962140930379407f64, + 5.235987755982989f64, + 5.523094417936056f64, + 6.0248765778844255f64, + 12.33319462629273f64, + 1.002517122345543f64, + ], + theta1: [ + 1321.331180819591f64, + 1321.331180819591f64, + -637.14117008679f64, + -126.11574641985825f64, + 8.834856673595295f64, + -17.73778118801837f64, + 2642.662361639182f64, + 2642.662361639182f64, + ], + }; +const NUTATION_PRECESSION_URANUS: NutationPrecessionCoefficients<18usize> = + NutationPrecessionCoefficients { + theta0: [ + 2.0202186091834364f64, + 2.4729570171507653f64, + 2.356718088967943f64, + 1.0780898789568973f64, + 4.351454891072263f64, + 0.7655014099247129f64, + 1.3554226970987964f64, + 2.746450110938277f64, + 1.776919711455427f64, + 2.419724474964938f64, + 1.784250094313803f64, + 5.522396286235258f64, + 5.3059754589879615f64, + 5.388005933831694f64, + 5.948431156647074f64, + 4.522846223618106f64, + 3.568500188627606f64, + 11.044792572470516f64, + ], + theta1: [ + 959.7891933286942f64, + 731.077582955928f64, + 522.3307938967249f64, + 449.1358738582876f64, + 427.10754977009157f64, + 388.83160660922994f64, + 354.1171823199879f64, + 290.6454915444109f64, + 224.66977689099764f64, + 140.70512817020406f64, + -35.32930378471962f64, + 49.9855316454168f64, + -0.9065240134858548f64, + -1.626123264083117f64, + -1.314581992602129f64, + -8.810596596992575f64, + -70.65860756943924f64, + 99.9710632908336f64, + ], + }; +const NUTATION_PRECESSION_NEPTUNE: NutationPrecessionCoefficients<17usize> = + NutationPrecessionCoefficients { + theta0: [ + 6.245660728261709f64, + 5.653470513060032f64, + 3.848625533572696f64, + 6.183177941040311f64, + 1.3144074596769295f64, + 0.6171484235051949f64, + 2.4890140462691135f64, + 3.104068074671915f64, + 11.306941026120064f64, + 6.20813614934383f64, + 9.312204224015744f64, + 12.41627229868766f64, + 15.520340373359575f64, + 18.624408448031488f64, + 21.728476522703406f64, + 24.83254459737532f64, + 27.936612672047236f64, + ], + theta1: [ + 0.9130864514733535f64, + 1092.6913034790819f64, + 961.0515899766616f64, + 812.7038395448996f64, + 455.6949957202075f64, + 250.02539666519567f64, + 49.29857005183183f64, + 0.9130864514733535f64, + 2185.3826069581637f64, + 1.826172902946707f64, + 2.7392593544200605f64, + 3.652345805893414f64, + 4.565432257366767f64, + 5.478518708840121f64, + 6.391605160313474f64, + 7.304691611786828f64, + 8.21777806326018f64, + ], + }; +impl MaybePointMass for DynOrigin { + fn maybe_gravitational_parameter(&self) -> Option { + match self { + DynOrigin::Sun => Some(132712440041.27942f64), + DynOrigin::Mercury => Some(22031.868551400003f64), + DynOrigin::Venus => Some(324858.592f64), + DynOrigin::Earth => Some(398600.43550702266f64), + DynOrigin::Mars => Some(42828.37362069909f64), + DynOrigin::Jupiter => Some(126686531.9003704f64), + DynOrigin::Saturn => Some(37931206.23436167f64), + DynOrigin::Uranus => Some(5793951.256527211f64), + DynOrigin::Neptune => Some(6835103.145462294f64), + DynOrigin::Pluto => Some(869.6138177608748f64), + DynOrigin::SolarSystemBarycenter => Some(132712440041.27942f64), + DynOrigin::MercuryBarycenter => Some(22031.868551400003f64), + DynOrigin::VenusBarycenter => Some(324858.592f64), + DynOrigin::EarthBarycenter => Some(403503.2356254802f64), + DynOrigin::MarsBarycenter => Some(42828.3758157561f64), + DynOrigin::JupiterBarycenter => Some(126712764.09999998f64), + DynOrigin::SaturnBarycenter => Some(37940584.8418f64), + DynOrigin::UranusBarycenter => Some(5794556.3999999985f64), + DynOrigin::NeptuneBarycenter => Some(6836527.100580399f64), + DynOrigin::PlutoBarycenter => Some(975.5f64), + DynOrigin::Moon => Some(4902.80011845755f64), + DynOrigin::Phobos => Some(0.0007087546066894452f64), + DynOrigin::Deimos => Some(0.00009615569648120313f64), + DynOrigin::Io => Some(5959.915466180539f64), + DynOrigin::Europa => Some(3202.712099607295f64), + DynOrigin::Ganymede => Some(9887.832752719638f64), + DynOrigin::Callisto => Some(7179.283402579837f64), + DynOrigin::Amalthea => Some(0.1645634534798259f64), + DynOrigin::Himalia => Some(0.1515524299611265f64), + DynOrigin::Thebe => Some(0.030148f64), + DynOrigin::Adrastea => Some(0.000139f64), + DynOrigin::Metis => Some(0.002501f64), + DynOrigin::Mimas => Some(2.503488768152587f64), + DynOrigin::Enceladus => Some(7.210366688598896f64), + DynOrigin::Tethys => Some(41.21352885489587f64), + DynOrigin::Dione => Some(73.11607172482067f64), + DynOrigin::Rhea => Some(153.9417519146563f64), + DynOrigin::Titan => Some(8978.137095521046f64), + DynOrigin::Hyperion => Some(0.3704913747932265f64), + DynOrigin::Iapetus => Some(120.5151060137642f64), + DynOrigin::Phoebe => Some(0.5547860052791678f64), + DynOrigin::Janus => Some(0.1265765099012197f64), + DynOrigin::Epimetheus => Some(0.03512333288208074f64), + DynOrigin::Helene => Some(0.0004757419551776972f64), + DynOrigin::Atlas => Some(0.0003718871247516475f64), + DynOrigin::Prometheus => Some(0.0107520800100761f64), + DynOrigin::Pandora => Some(0.009290325122028795f64), + DynOrigin::Ariel => Some(83.46344431770477f64), + DynOrigin::Umbriel => Some(85.09338094489388f64), + DynOrigin::Titania => Some(226.9437003741248f64), + DynOrigin::Oberon => Some(205.3234302535623f64), + DynOrigin::Miranda => Some(4.3195168992321f64), + DynOrigin::Triton => Some(1428.495462910464f64), + DynOrigin::Naiad => Some(0.008530281246540886f64), + DynOrigin::Thalassa => Some(0.0235887319799217f64), + DynOrigin::Despina => Some(0.1167318403814998f64), + DynOrigin::Galatea => Some(0.189898503906069f64), + DynOrigin::Larissa => Some(0.2548437405693583f64), + DynOrigin::Proteus => Some(2.583422379120727f64), + DynOrigin::Charon => Some(105.8799888601881f64), + DynOrigin::Nix => Some(0.00304817564816976f64), + DynOrigin::Hydra => Some(0.003211039206155255f64), + DynOrigin::Kerberos => Some(0.001110040850536676f64), + DynOrigin::Styx => Some(0f64), + DynOrigin::Ceres => Some(62.62888864440993f64), + DynOrigin::Pallas => Some(13.665878145967422f64), + DynOrigin::Vesta => Some(17.288232879171513f64), + DynOrigin::Psyche => Some(1.5896582441709424f64), + DynOrigin::Eros => Some(0.0004463f64), + DynOrigin::Davida => Some(3.8944831481705644f64), + _ => None, + } + } +} +impl MaybeMeanRadius for DynOrigin { + fn maybe_mean_radius(&self) -> Option { + match self { + DynOrigin::Mercury => Some(2439.4f64), + DynOrigin::Venus => Some(6051.8f64), + DynOrigin::Earth => Some(6371.0084f64), + DynOrigin::Mars => Some(3389.5f64), + DynOrigin::Jupiter => Some(69911f64), + DynOrigin::Saturn => Some(58232f64), + DynOrigin::Uranus => Some(25362f64), + DynOrigin::Neptune => Some(24622f64), + DynOrigin::Pluto => Some(1188.3f64), + DynOrigin::Moon => Some(1737.4f64), + DynOrigin::Phobos => Some(11.08f64), + DynOrigin::Deimos => Some(6.2f64), + DynOrigin::Io => Some(1821.49f64), + DynOrigin::Europa => Some(1560.8f64), + DynOrigin::Ganymede => Some(2631.2f64), + DynOrigin::Callisto => Some(2410.3f64), + DynOrigin::Amalthea => Some(83.5f64), + DynOrigin::Himalia => Some(85f64), + DynOrigin::Elara => Some(40f64), + DynOrigin::Pasiphae => Some(18f64), + DynOrigin::Sinope => Some(14f64), + DynOrigin::Lysithea => Some(12f64), + DynOrigin::Carme => Some(15f64), + DynOrigin::Ananke => Some(10f64), + DynOrigin::Leda => Some(5f64), + DynOrigin::Thebe => Some(49.3f64), + DynOrigin::Adrastea => Some(8.2f64), + DynOrigin::Metis => Some(21.5f64), + DynOrigin::Mimas => Some(198.2f64), + DynOrigin::Enceladus => Some(252.1f64), + DynOrigin::Tethys => Some(531f64), + DynOrigin::Dione => Some(561.4f64), + DynOrigin::Rhea => Some(763.5f64), + DynOrigin::Titan => Some(2575f64), + DynOrigin::Hyperion => Some(135f64), + DynOrigin::Iapetus => Some(734.3f64), + DynOrigin::Phoebe => Some(106.5f64), + DynOrigin::Janus => Some(89.2f64), + DynOrigin::Epimetheus => Some(58.2f64), + DynOrigin::Helene => Some(18f64), + DynOrigin::Telesto => Some(12.4f64), + DynOrigin::Calypso => Some(9.6f64), + DynOrigin::Atlas => Some(15.1f64), + DynOrigin::Prometheus => Some(43.1f64), + DynOrigin::Pandora => Some(40.6f64), + DynOrigin::Pan => Some(14f64), + DynOrigin::Methone => Some(1.45f64), + DynOrigin::Pallene => Some(2.23f64), + DynOrigin::Polydeuces => Some(1.3f64), + DynOrigin::Daphnis => Some(3.8f64), + DynOrigin::Anthe => Some(0.5f64), + DynOrigin::Aegaeon => Some(0.33f64), + DynOrigin::Ariel => Some(578.9f64), + DynOrigin::Umbriel => Some(584.7f64), + DynOrigin::Titania => Some(788.9f64), + DynOrigin::Oberon => Some(761.4f64), + DynOrigin::Miranda => Some(235.8f64), + DynOrigin::Cordelia => Some(13f64), + DynOrigin::Ophelia => Some(15f64), + DynOrigin::Bianca => Some(21f64), + DynOrigin::Cressida => Some(31f64), + DynOrigin::Desdemona => Some(27f64), + DynOrigin::Juliet => Some(42f64), + DynOrigin::Portia => Some(54f64), + DynOrigin::Rosalind => Some(27f64), + DynOrigin::Belinda => Some(33f64), + DynOrigin::Puck => Some(77f64), + DynOrigin::Triton => Some(1352.6f64), + DynOrigin::Nereid => Some(170f64), + DynOrigin::Naiad => Some(29f64), + DynOrigin::Thalassa => Some(40f64), + DynOrigin::Despina => Some(74f64), + DynOrigin::Galatea => Some(79f64), + DynOrigin::Larissa => Some(96f64), + DynOrigin::Proteus => Some(208f64), + DynOrigin::Charon => Some(606f64), + DynOrigin::Gaspra => Some(6.1f64), + DynOrigin::Ida => Some(15.65f64), + DynOrigin::Ceres => Some(470f64), + DynOrigin::Psyche => Some(113f64), + DynOrigin::Lutetia => Some(52.5f64), + DynOrigin::Eros => Some(8.45f64), + DynOrigin::Davida => Some(150f64), + DynOrigin::Mathilde => Some(26.5f64), + DynOrigin::Steins => Some(2.7f64), + _ => None, + } + } +} +impl MaybeTriaxialEllipsoid for DynOrigin { + fn maybe_radii(&self) -> Option { + match self { + DynOrigin::Sun => Some((695700f64, 695700f64, 695700f64)), + DynOrigin::Mercury => Some((2440.53f64, 2440.53f64, 2438.26f64)), + DynOrigin::Venus => Some((6051.8f64, 6051.8f64, 6051.8f64)), + DynOrigin::Earth => Some((6378.1366f64, 6378.1366f64, 6356.7519f64)), + DynOrigin::Mars => Some((3396.19f64, 3396.19f64, 3376.2f64)), + DynOrigin::Jupiter => Some((71492f64, 71492f64, 66854f64)), + DynOrigin::Saturn => Some((60268f64, 60268f64, 54364f64)), + DynOrigin::Uranus => Some((25559f64, 25559f64, 24973f64)), + DynOrigin::Neptune => Some((24764f64, 24764f64, 24341f64)), + DynOrigin::Pluto => Some((1188.3f64, 1188.3f64, 1188.3f64)), + DynOrigin::Moon => Some((1737.4f64, 1737.4f64, 1737.4f64)), + DynOrigin::Phobos => Some((13f64, 11.4f64, 9.1f64)), + DynOrigin::Deimos => Some((7.8f64, 6f64, 5.1f64)), + DynOrigin::Io => Some((1829.4f64, 1819.4f64, 1815.7f64)), + DynOrigin::Europa => Some((1562.6f64, 1560.3f64, 1559.5f64)), + DynOrigin::Ganymede => Some((2631.2f64, 2631.2f64, 2631.2f64)), + DynOrigin::Callisto => Some((2410.3f64, 2410.3f64, 2410.3f64)), + DynOrigin::Amalthea => Some((125f64, 73f64, 64f64)), + DynOrigin::Himalia => Some((85f64, 85f64, 85f64)), + DynOrigin::Elara => Some((40f64, 40f64, 40f64)), + DynOrigin::Pasiphae => Some((18f64, 18f64, 18f64)), + DynOrigin::Sinope => Some((14f64, 14f64, 14f64)), + DynOrigin::Lysithea => Some((12f64, 12f64, 12f64)), + DynOrigin::Carme => Some((15f64, 15f64, 15f64)), + DynOrigin::Ananke => Some((10f64, 10f64, 10f64)), + DynOrigin::Leda => Some((5f64, 5f64, 5f64)), + DynOrigin::Thebe => Some((58f64, 49f64, 42f64)), + DynOrigin::Adrastea => Some((10f64, 8f64, 7f64)), + DynOrigin::Metis => Some((30f64, 20f64, 17f64)), + DynOrigin::Mimas => Some((207.8f64, 196.7f64, 190.6f64)), + DynOrigin::Enceladus => Some((256.6f64, 251.4f64, 248.3f64)), + DynOrigin::Tethys => Some((538.4f64, 528.3f64, 526.3f64)), + DynOrigin::Dione => Some((563.4f64, 561.3f64, 559.6f64)), + DynOrigin::Rhea => Some((765f64, 763.1f64, 762.4f64)), + DynOrigin::Titan => Some((2575.15f64, 2574.78f64, 2574.47f64)), + DynOrigin::Hyperion => Some((180.1f64, 133f64, 102.7f64)), + DynOrigin::Iapetus => Some((745.7f64, 745.7f64, 712.1f64)), + DynOrigin::Phoebe => Some((109.4f64, 108.5f64, 101.8f64)), + DynOrigin::Janus => Some((101.7f64, 93f64, 76.3f64)), + DynOrigin::Epimetheus => Some((64.9f64, 57.3f64, 53f64)), + DynOrigin::Helene => Some((22.5f64, 19.6f64, 13.3f64)), + DynOrigin::Telesto => Some((16.3f64, 11.8f64, 9.8f64)), + DynOrigin::Calypso => Some((15.3f64, 9.3f64, 6.3f64)), + DynOrigin::Atlas => Some((20.5f64, 17.8f64, 9.4f64)), + DynOrigin::Prometheus => Some((68.2f64, 41.6f64, 28.2f64)), + DynOrigin::Pandora => Some((52.2f64, 40.8f64, 31.5f64)), + DynOrigin::Pan => Some((17.2f64, 15.4f64, 10.4f64)), + DynOrigin::Methone => Some((1.94f64, 1.29f64, 1.21f64)), + DynOrigin::Pallene => Some((2.88f64, 2.08f64, 1.8f64)), + DynOrigin::Polydeuces => Some((1.5f64, 1.2f64, 1f64)), + DynOrigin::Daphnis => Some((4.6f64, 4.5f64, 2.8f64)), + DynOrigin::Anthe => Some((0.5f64, 0.5f64, 0.5f64)), + DynOrigin::Aegaeon => Some((0.7f64, 0.25f64, 0.2f64)), + DynOrigin::Ariel => Some((581.1f64, 577.9f64, 577.7f64)), + DynOrigin::Umbriel => Some((584.7f64, 584.7f64, 584.7f64)), + DynOrigin::Titania => Some((788.9f64, 788.9f64, 788.9f64)), + DynOrigin::Oberon => Some((761.4f64, 761.4f64, 761.4f64)), + DynOrigin::Miranda => Some((240.4f64, 234.2f64, 232.9f64)), + DynOrigin::Cordelia => Some((13f64, 13f64, 13f64)), + DynOrigin::Ophelia => Some((15f64, 15f64, 15f64)), + DynOrigin::Bianca => Some((21f64, 21f64, 21f64)), + DynOrigin::Cressida => Some((31f64, 31f64, 31f64)), + DynOrigin::Desdemona => Some((27f64, 27f64, 27f64)), + DynOrigin::Juliet => Some((42f64, 42f64, 42f64)), + DynOrigin::Portia => Some((54f64, 54f64, 54f64)), + DynOrigin::Rosalind => Some((27f64, 27f64, 27f64)), + DynOrigin::Belinda => Some((33f64, 33f64, 33f64)), + DynOrigin::Puck => Some((77f64, 77f64, 77f64)), + DynOrigin::Triton => Some((1352.6f64, 1352.6f64, 1352.6f64)), + DynOrigin::Nereid => Some((170f64, 170f64, 170f64)), + DynOrigin::Naiad => Some((29f64, 29f64, 29f64)), + DynOrigin::Thalassa => Some((40f64, 40f64, 40f64)), + DynOrigin::Despina => Some((74f64, 74f64, 74f64)), + DynOrigin::Galatea => Some((79f64, 79f64, 79f64)), + DynOrigin::Larissa => Some((96f64, 96f64, 96f64)), + DynOrigin::Proteus => Some((218f64, 208f64, 201f64)), + DynOrigin::Charon => Some((606f64, 606f64, 606f64)), + DynOrigin::Gaspra => Some((9.1f64, 5.2f64, 4.4f64)), + DynOrigin::Ida => Some((26.8f64, 12f64, 7.6f64)), + DynOrigin::Ceres => Some((487.3f64, 487.3f64, 446f64)), + DynOrigin::Vesta => Some((289f64, 280f64, 229f64)), + DynOrigin::Psyche => Some((139.5f64, 116f64, 94.5f64)), + DynOrigin::Lutetia => Some((62f64, 50.5f64, 46.5f64)), + DynOrigin::Eros => Some((17f64, 5.5f64, 5.5f64)), + DynOrigin::Davida => Some((180f64, 147f64, 127f64)), + DynOrigin::Mathilde => Some((33f64, 24f64, 23f64)), + DynOrigin::Steins => Some((3.24f64, 2.73f64, 2.04f64)), + DynOrigin::Toutatis => Some((2.13f64, 1.015f64, 0.85f64)), + DynOrigin::Itokawa => Some((0.268f64, 0.147f64, 0.104f64)), + _ => None, + } + } +} +impl MaybeSpheroid for DynOrigin {} +impl TryRotationalElements for DynOrigin { + fn try_rotational_elements( + &self, + t: f64, + ) -> Result { + match self { + DynOrigin::Sun => Ok(( + RIGHT_ASCENSION_SUN.angle::<0usize>(None, t), + DECLINATION_SUN.angle::<0usize>(None, t), + ROTATION_SUN.angle::<0usize>(None, t), + )), + DynOrigin::Mercury => Ok(( + RIGHT_ASCENSION_MERCURY.angle::<5usize>(Some(&NUTATION_PRECESSION_MERCURY), t), + DECLINATION_MERCURY.angle::<5usize>(Some(&NUTATION_PRECESSION_MERCURY), t), + ROTATION_MERCURY.angle::<5usize>(Some(&NUTATION_PRECESSION_MERCURY), t), + )), + DynOrigin::Venus => Ok(( + RIGHT_ASCENSION_VENUS.angle::<0usize>(None, t), + DECLINATION_VENUS.angle::<0usize>(None, t), + ROTATION_VENUS.angle::<0usize>(None, t), + )), + DynOrigin::Earth => Ok(( + RIGHT_ASCENSION_EARTH.angle::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + DECLINATION_EARTH.angle::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + ROTATION_EARTH.angle::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + )), + DynOrigin::Mars => Ok(( + RIGHT_ASCENSION_MARS.angle::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + DECLINATION_MARS.angle::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + ROTATION_MARS.angle::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + )), + DynOrigin::Jupiter => Ok(( + RIGHT_ASCENSION_JUPITER.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_JUPITER.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_JUPITER.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + )), + DynOrigin::Saturn => Ok(( + RIGHT_ASCENSION_SATURN.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_SATURN.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_SATURN.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Uranus => Ok(( + RIGHT_ASCENSION_URANUS.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_URANUS.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_URANUS.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Neptune => Ok(( + RIGHT_ASCENSION_NEPTUNE.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_NEPTUNE.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_NEPTUNE.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + )), + DynOrigin::Pluto => Ok(( + RIGHT_ASCENSION_PLUTO.angle::<0usize>(None, t), + DECLINATION_PLUTO.angle::<0usize>(None, t), + ROTATION_PLUTO.angle::<0usize>(None, t), + )), + DynOrigin::Moon => Ok(( + RIGHT_ASCENSION_MOON.angle::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + DECLINATION_MOON.angle::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + ROTATION_MOON.angle::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + )), + DynOrigin::Phobos => Ok(( + RIGHT_ASCENSION_PHOBOS.angle::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + DECLINATION_PHOBOS.angle::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + ROTATION_PHOBOS.angle::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + )), + DynOrigin::Deimos => Ok(( + RIGHT_ASCENSION_DEIMOS.angle::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + DECLINATION_DEIMOS.angle::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + ROTATION_DEIMOS.angle::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + )), + DynOrigin::Io => Ok(( + RIGHT_ASCENSION_IO.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_IO.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_IO.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + )), + DynOrigin::Europa => Ok(( + RIGHT_ASCENSION_EUROPA.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_EUROPA.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_EUROPA.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + )), + DynOrigin::Ganymede => Ok(( + RIGHT_ASCENSION_GANYMEDE.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_GANYMEDE.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_GANYMEDE.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + )), + DynOrigin::Callisto => Ok(( + RIGHT_ASCENSION_CALLISTO.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_CALLISTO.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_CALLISTO.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + )), + DynOrigin::Amalthea => Ok(( + RIGHT_ASCENSION_AMALTHEA.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_AMALTHEA.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_AMALTHEA.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + )), + DynOrigin::Thebe => Ok(( + RIGHT_ASCENSION_THEBE.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_THEBE.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_THEBE.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + )), + DynOrigin::Adrastea => Ok(( + RIGHT_ASCENSION_ADRASTEA.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_ADRASTEA.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_ADRASTEA.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + )), + DynOrigin::Metis => Ok(( + RIGHT_ASCENSION_METIS.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_METIS.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_METIS.angle::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + )), + DynOrigin::Mimas => Ok(( + RIGHT_ASCENSION_MIMAS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_MIMAS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_MIMAS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Enceladus => Ok(( + RIGHT_ASCENSION_ENCELADUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_ENCELADUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_ENCELADUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Tethys => Ok(( + RIGHT_ASCENSION_TETHYS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_TETHYS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_TETHYS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Dione => Ok(( + RIGHT_ASCENSION_DIONE.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_DIONE.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_DIONE.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Rhea => Ok(( + RIGHT_ASCENSION_RHEA.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_RHEA.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_RHEA.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Titan => Ok(( + RIGHT_ASCENSION_TITAN.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_TITAN.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_TITAN.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Iapetus => Ok(( + RIGHT_ASCENSION_IAPETUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_IAPETUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_IAPETUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Phoebe => Ok(( + RIGHT_ASCENSION_PHOEBE.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_PHOEBE.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_PHOEBE.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Janus => Ok(( + RIGHT_ASCENSION_JANUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_JANUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_JANUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Epimetheus => Ok(( + RIGHT_ASCENSION_EPIMETHEUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_EPIMETHEUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_EPIMETHEUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Helene => Ok(( + RIGHT_ASCENSION_HELENE.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_HELENE.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_HELENE.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Telesto => Ok(( + RIGHT_ASCENSION_TELESTO.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_TELESTO.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_TELESTO.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Calypso => Ok(( + RIGHT_ASCENSION_CALYPSO.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_CALYPSO.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_CALYPSO.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Atlas => Ok(( + RIGHT_ASCENSION_ATLAS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_ATLAS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_ATLAS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Prometheus => Ok(( + RIGHT_ASCENSION_PROMETHEUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_PROMETHEUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_PROMETHEUS.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Pandora => Ok(( + RIGHT_ASCENSION_PANDORA.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_PANDORA.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_PANDORA.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Pan => Ok(( + RIGHT_ASCENSION_PAN.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_PAN.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_PAN.angle::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Ariel => Ok(( + RIGHT_ASCENSION_ARIEL.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_ARIEL.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_ARIEL.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Umbriel => Ok(( + RIGHT_ASCENSION_UMBRIEL.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_UMBRIEL.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_UMBRIEL.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Titania => Ok(( + RIGHT_ASCENSION_TITANIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_TITANIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_TITANIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Oberon => Ok(( + RIGHT_ASCENSION_OBERON.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_OBERON.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_OBERON.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Miranda => Ok(( + RIGHT_ASCENSION_MIRANDA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_MIRANDA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_MIRANDA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Cordelia => Ok(( + RIGHT_ASCENSION_CORDELIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_CORDELIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_CORDELIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Ophelia => Ok(( + RIGHT_ASCENSION_OPHELIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_OPHELIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_OPHELIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Bianca => Ok(( + RIGHT_ASCENSION_BIANCA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_BIANCA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_BIANCA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Cressida => Ok(( + RIGHT_ASCENSION_CRESSIDA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_CRESSIDA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_CRESSIDA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Desdemona => Ok(( + RIGHT_ASCENSION_DESDEMONA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_DESDEMONA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_DESDEMONA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Juliet => Ok(( + RIGHT_ASCENSION_JULIET.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_JULIET.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_JULIET.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Portia => Ok(( + RIGHT_ASCENSION_PORTIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_PORTIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_PORTIA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Rosalind => Ok(( + RIGHT_ASCENSION_ROSALIND.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_ROSALIND.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_ROSALIND.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Belinda => Ok(( + RIGHT_ASCENSION_BELINDA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_BELINDA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_BELINDA.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Puck => Ok(( + RIGHT_ASCENSION_PUCK.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_PUCK.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_PUCK.angle::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Triton => Ok(( + RIGHT_ASCENSION_TRITON.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_TRITON.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_TRITON.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + )), + DynOrigin::Naiad => Ok(( + RIGHT_ASCENSION_NAIAD.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_NAIAD.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_NAIAD.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + )), + DynOrigin::Thalassa => Ok(( + RIGHT_ASCENSION_THALASSA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_THALASSA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_THALASSA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + )), + DynOrigin::Despina => Ok(( + RIGHT_ASCENSION_DESPINA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_DESPINA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_DESPINA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + )), + DynOrigin::Galatea => Ok(( + RIGHT_ASCENSION_GALATEA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_GALATEA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_GALATEA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + )), + DynOrigin::Larissa => Ok(( + RIGHT_ASCENSION_LARISSA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_LARISSA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_LARISSA.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + )), + DynOrigin::Proteus => Ok(( + RIGHT_ASCENSION_PROTEUS.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_PROTEUS.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_PROTEUS.angle::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + )), + DynOrigin::Charon => Ok(( + RIGHT_ASCENSION_CHARON.angle::<0usize>(None, t), + DECLINATION_CHARON.angle::<0usize>(None, t), + ROTATION_CHARON.angle::<0usize>(None, t), + )), + DynOrigin::Gaspra => Ok(( + RIGHT_ASCENSION_GASPRA.angle::<0usize>(None, t), + DECLINATION_GASPRA.angle::<0usize>(None, t), + ROTATION_GASPRA.angle::<0usize>(None, t), + )), + DynOrigin::Ida => Ok(( + RIGHT_ASCENSION_IDA.angle::<0usize>(None, t), + DECLINATION_IDA.angle::<0usize>(None, t), + ROTATION_IDA.angle::<0usize>(None, t), + )), + DynOrigin::Ceres => Ok(( + RIGHT_ASCENSION_CERES.angle::<0usize>(None, t), + DECLINATION_CERES.angle::<0usize>(None, t), + ROTATION_CERES.angle::<0usize>(None, t), + )), + DynOrigin::Pallas => Ok(( + RIGHT_ASCENSION_PALLAS.angle::<0usize>(None, t), + DECLINATION_PALLAS.angle::<0usize>(None, t), + ROTATION_PALLAS.angle::<0usize>(None, t), + )), + DynOrigin::Vesta => Ok(( + RIGHT_ASCENSION_VESTA.angle::<0usize>(None, t), + DECLINATION_VESTA.angle::<0usize>(None, t), + ROTATION_VESTA.angle::<0usize>(None, t), + )), + DynOrigin::Lutetia => Ok(( + RIGHT_ASCENSION_LUTETIA.angle::<0usize>(None, t), + DECLINATION_LUTETIA.angle::<0usize>(None, t), + ROTATION_LUTETIA.angle::<0usize>(None, t), + )), + DynOrigin::Eros => Ok(( + RIGHT_ASCENSION_EROS.angle::<0usize>(None, t), + DECLINATION_EROS.angle::<0usize>(None, t), + ROTATION_EROS.angle::<0usize>(None, t), + )), + DynOrigin::Davida => Ok(( + RIGHT_ASCENSION_DAVIDA.angle::<0usize>(None, t), + DECLINATION_DAVIDA.angle::<0usize>(None, t), + ROTATION_DAVIDA.angle::<0usize>(None, t), + )), + DynOrigin::Steins => Ok(( + RIGHT_ASCENSION_STEINS.angle::<0usize>(None, t), + DECLINATION_STEINS.angle::<0usize>(None, t), + ROTATION_STEINS.angle::<0usize>(None, t), + )), + DynOrigin::Itokawa => Ok(( + RIGHT_ASCENSION_ITOKAWA.angle::<0usize>(None, t), + DECLINATION_ITOKAWA.angle::<0usize>(None, t), + ROTATION_ITOKAWA.angle::<0usize>(None, t), + )), + _ => Err(UndefinedRotationalElementsError(self.name().to_string())), + } + } + fn try_rotational_element_rates( + &self, + t: f64, + ) -> Result { + match self { + DynOrigin::Sun => Ok(( + RIGHT_ASCENSION_SUN.angle_dot::<0usize>(None, t), + DECLINATION_SUN.angle_dot::<0usize>(None, t), + ROTATION_SUN.angle_dot::<0usize>(None, t), + )), + DynOrigin::Mercury => Ok(( + RIGHT_ASCENSION_MERCURY.angle_dot::<5usize>(Some(&NUTATION_PRECESSION_MERCURY), t), + DECLINATION_MERCURY.angle_dot::<5usize>(Some(&NUTATION_PRECESSION_MERCURY), t), + ROTATION_MERCURY.angle_dot::<5usize>(Some(&NUTATION_PRECESSION_MERCURY), t), + )), + DynOrigin::Venus => Ok(( + RIGHT_ASCENSION_VENUS.angle_dot::<0usize>(None, t), + DECLINATION_VENUS.angle_dot::<0usize>(None, t), + ROTATION_VENUS.angle_dot::<0usize>(None, t), + )), + DynOrigin::Earth => Ok(( + RIGHT_ASCENSION_EARTH.angle_dot::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + DECLINATION_EARTH.angle_dot::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + ROTATION_EARTH.angle_dot::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + )), + DynOrigin::Mars => Ok(( + RIGHT_ASCENSION_MARS.angle_dot::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + DECLINATION_MARS.angle_dot::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + ROTATION_MARS.angle_dot::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + )), + DynOrigin::Jupiter => Ok(( + RIGHT_ASCENSION_JUPITER.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_JUPITER.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_JUPITER.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + )), + DynOrigin::Saturn => Ok(( + RIGHT_ASCENSION_SATURN.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_SATURN.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_SATURN.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Uranus => Ok(( + RIGHT_ASCENSION_URANUS.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_URANUS.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_URANUS.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Neptune => Ok(( + RIGHT_ASCENSION_NEPTUNE.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_NEPTUNE.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_NEPTUNE.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + )), + DynOrigin::Pluto => Ok(( + RIGHT_ASCENSION_PLUTO.angle_dot::<0usize>(None, t), + DECLINATION_PLUTO.angle_dot::<0usize>(None, t), + ROTATION_PLUTO.angle_dot::<0usize>(None, t), + )), + DynOrigin::Moon => Ok(( + RIGHT_ASCENSION_MOON.angle_dot::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + DECLINATION_MOON.angle_dot::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + ROTATION_MOON.angle_dot::<13usize>(Some(&NUTATION_PRECESSION_EARTH), t), + )), + DynOrigin::Phobos => Ok(( + RIGHT_ASCENSION_PHOBOS.angle_dot::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + DECLINATION_PHOBOS.angle_dot::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + ROTATION_PHOBOS.angle_dot::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + )), + DynOrigin::Deimos => Ok(( + RIGHT_ASCENSION_DEIMOS.angle_dot::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + DECLINATION_DEIMOS.angle_dot::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + ROTATION_DEIMOS.angle_dot::<26usize>(Some(&NUTATION_PRECESSION_MARS), t), + )), + DynOrigin::Io => Ok(( + RIGHT_ASCENSION_IO.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_IO.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_IO.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + )), + DynOrigin::Europa => Ok(( + RIGHT_ASCENSION_EUROPA.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_EUROPA.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_EUROPA.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + )), + DynOrigin::Ganymede => Ok(( + RIGHT_ASCENSION_GANYMEDE + .angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_GANYMEDE.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_GANYMEDE.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + )), + DynOrigin::Callisto => Ok(( + RIGHT_ASCENSION_CALLISTO + .angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_CALLISTO.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_CALLISTO.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + )), + DynOrigin::Amalthea => Ok(( + RIGHT_ASCENSION_AMALTHEA + .angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_AMALTHEA.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_AMALTHEA.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + )), + DynOrigin::Thebe => Ok(( + RIGHT_ASCENSION_THEBE.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_THEBE.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_THEBE.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + )), + DynOrigin::Adrastea => Ok(( + RIGHT_ASCENSION_ADRASTEA + .angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_ADRASTEA.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_ADRASTEA.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + )), + DynOrigin::Metis => Ok(( + RIGHT_ASCENSION_METIS.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_METIS.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_METIS.angle_dot::<15usize>(Some(&NUTATION_PRECESSION_JUPITER), t), + )), + DynOrigin::Mimas => Ok(( + RIGHT_ASCENSION_MIMAS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_MIMAS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_MIMAS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Enceladus => Ok(( + RIGHT_ASCENSION_ENCELADUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_ENCELADUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_ENCELADUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Tethys => Ok(( + RIGHT_ASCENSION_TETHYS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_TETHYS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_TETHYS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Dione => Ok(( + RIGHT_ASCENSION_DIONE.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_DIONE.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_DIONE.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Rhea => Ok(( + RIGHT_ASCENSION_RHEA.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_RHEA.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_RHEA.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Titan => Ok(( + RIGHT_ASCENSION_TITAN.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_TITAN.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_TITAN.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Iapetus => Ok(( + RIGHT_ASCENSION_IAPETUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_IAPETUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_IAPETUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Phoebe => Ok(( + RIGHT_ASCENSION_PHOEBE.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_PHOEBE.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_PHOEBE.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Janus => Ok(( + RIGHT_ASCENSION_JANUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_JANUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_JANUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Epimetheus => Ok(( + RIGHT_ASCENSION_EPIMETHEUS + .angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_EPIMETHEUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_EPIMETHEUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Helene => Ok(( + RIGHT_ASCENSION_HELENE.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_HELENE.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_HELENE.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Telesto => Ok(( + RIGHT_ASCENSION_TELESTO.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_TELESTO.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_TELESTO.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Calypso => Ok(( + RIGHT_ASCENSION_CALYPSO.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_CALYPSO.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_CALYPSO.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Atlas => Ok(( + RIGHT_ASCENSION_ATLAS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_ATLAS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_ATLAS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Prometheus => Ok(( + RIGHT_ASCENSION_PROMETHEUS + .angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_PROMETHEUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_PROMETHEUS.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Pandora => Ok(( + RIGHT_ASCENSION_PANDORA.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_PANDORA.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_PANDORA.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Pan => Ok(( + RIGHT_ASCENSION_PAN.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + DECLINATION_PAN.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + ROTATION_PAN.angle_dot::<8usize>(Some(&NUTATION_PRECESSION_SATURN), t), + )), + DynOrigin::Ariel => Ok(( + RIGHT_ASCENSION_ARIEL.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_ARIEL.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_ARIEL.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Umbriel => Ok(( + RIGHT_ASCENSION_UMBRIEL.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_UMBRIEL.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_UMBRIEL.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Titania => Ok(( + RIGHT_ASCENSION_TITANIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_TITANIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_TITANIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Oberon => Ok(( + RIGHT_ASCENSION_OBERON.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_OBERON.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_OBERON.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Miranda => Ok(( + RIGHT_ASCENSION_MIRANDA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_MIRANDA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_MIRANDA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Cordelia => Ok(( + RIGHT_ASCENSION_CORDELIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_CORDELIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_CORDELIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Ophelia => Ok(( + RIGHT_ASCENSION_OPHELIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_OPHELIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_OPHELIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Bianca => Ok(( + RIGHT_ASCENSION_BIANCA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_BIANCA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_BIANCA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Cressida => Ok(( + RIGHT_ASCENSION_CRESSIDA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_CRESSIDA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_CRESSIDA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Desdemona => Ok(( + RIGHT_ASCENSION_DESDEMONA + .angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_DESDEMONA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_DESDEMONA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Juliet => Ok(( + RIGHT_ASCENSION_JULIET.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_JULIET.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_JULIET.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Portia => Ok(( + RIGHT_ASCENSION_PORTIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_PORTIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_PORTIA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Rosalind => Ok(( + RIGHT_ASCENSION_ROSALIND.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_ROSALIND.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_ROSALIND.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Belinda => Ok(( + RIGHT_ASCENSION_BELINDA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_BELINDA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_BELINDA.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Puck => Ok(( + RIGHT_ASCENSION_PUCK.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + DECLINATION_PUCK.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + ROTATION_PUCK.angle_dot::<18usize>(Some(&NUTATION_PRECESSION_URANUS), t), + )), + DynOrigin::Triton => Ok(( + RIGHT_ASCENSION_TRITON.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_TRITON.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_TRITON.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + )), + DynOrigin::Naiad => Ok(( + RIGHT_ASCENSION_NAIAD.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_NAIAD.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_NAIAD.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + )), + DynOrigin::Thalassa => Ok(( + RIGHT_ASCENSION_THALASSA + .angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_THALASSA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_THALASSA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + )), + DynOrigin::Despina => Ok(( + RIGHT_ASCENSION_DESPINA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_DESPINA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_DESPINA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + )), + DynOrigin::Galatea => Ok(( + RIGHT_ASCENSION_GALATEA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_GALATEA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_GALATEA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + )), + DynOrigin::Larissa => Ok(( + RIGHT_ASCENSION_LARISSA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_LARISSA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_LARISSA.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + )), + DynOrigin::Proteus => Ok(( + RIGHT_ASCENSION_PROTEUS.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + DECLINATION_PROTEUS.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + ROTATION_PROTEUS.angle_dot::<17usize>(Some(&NUTATION_PRECESSION_NEPTUNE), t), + )), + DynOrigin::Charon => Ok(( + RIGHT_ASCENSION_CHARON.angle_dot::<0usize>(None, t), + DECLINATION_CHARON.angle_dot::<0usize>(None, t), + ROTATION_CHARON.angle_dot::<0usize>(None, t), + )), + DynOrigin::Gaspra => Ok(( + RIGHT_ASCENSION_GASPRA.angle_dot::<0usize>(None, t), + DECLINATION_GASPRA.angle_dot::<0usize>(None, t), + ROTATION_GASPRA.angle_dot::<0usize>(None, t), + )), + DynOrigin::Ida => Ok(( + RIGHT_ASCENSION_IDA.angle_dot::<0usize>(None, t), + DECLINATION_IDA.angle_dot::<0usize>(None, t), + ROTATION_IDA.angle_dot::<0usize>(None, t), + )), + DynOrigin::Ceres => Ok(( + RIGHT_ASCENSION_CERES.angle_dot::<0usize>(None, t), + DECLINATION_CERES.angle_dot::<0usize>(None, t), + ROTATION_CERES.angle_dot::<0usize>(None, t), + )), + DynOrigin::Pallas => Ok(( + RIGHT_ASCENSION_PALLAS.angle_dot::<0usize>(None, t), + DECLINATION_PALLAS.angle_dot::<0usize>(None, t), + ROTATION_PALLAS.angle_dot::<0usize>(None, t), + )), + DynOrigin::Vesta => Ok(( + RIGHT_ASCENSION_VESTA.angle_dot::<0usize>(None, t), + DECLINATION_VESTA.angle_dot::<0usize>(None, t), + ROTATION_VESTA.angle_dot::<0usize>(None, t), + )), + DynOrigin::Lutetia => Ok(( + RIGHT_ASCENSION_LUTETIA.angle_dot::<0usize>(None, t), + DECLINATION_LUTETIA.angle_dot::<0usize>(None, t), + ROTATION_LUTETIA.angle_dot::<0usize>(None, t), + )), + DynOrigin::Eros => Ok(( + RIGHT_ASCENSION_EROS.angle_dot::<0usize>(None, t), + DECLINATION_EROS.angle_dot::<0usize>(None, t), + ROTATION_EROS.angle_dot::<0usize>(None, t), + )), + DynOrigin::Davida => Ok(( + RIGHT_ASCENSION_DAVIDA.angle_dot::<0usize>(None, t), + DECLINATION_DAVIDA.angle_dot::<0usize>(None, t), + ROTATION_DAVIDA.angle_dot::<0usize>(None, t), + )), + DynOrigin::Steins => Ok(( + RIGHT_ASCENSION_STEINS.angle_dot::<0usize>(None, t), + DECLINATION_STEINS.angle_dot::<0usize>(None, t), + ROTATION_STEINS.angle_dot::<0usize>(None, t), + )), + DynOrigin::Itokawa => Ok(( + RIGHT_ASCENSION_ITOKAWA.angle_dot::<0usize>(None, t), + DECLINATION_ITOKAWA.angle_dot::<0usize>(None, t), + ROTATION_ITOKAWA.angle_dot::<0usize>(None, t), + )), + _ => Err(UndefinedRotationalElementsError(self.name().to_string())), + } + } +} diff --git a/crates/lox-bodies/src/generated/barycenters.rs b/crates/lox-bodies/src/generated/barycenters.rs deleted file mode 100644 index 3c0629e3..00000000 --- a/crates/lox-bodies/src/generated/barycenters.rs +++ /dev/null @@ -1,339 +0,0 @@ -/* - * 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::{Barycenter, Body, NaifId, PointMass}; -use std::fmt::{Display, Formatter}; -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct SolarSystemBarycenter; -impl Barycenter for SolarSystemBarycenter {} -impl Body for SolarSystemBarycenter { - fn id(&self) -> NaifId { - NaifId(0i32) - } - fn name(&self) -> &'static str { - "Solar System Barycenter" - } -} -impl Display for SolarSystemBarycenter { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct MercuryBarycenter; -impl Barycenter for MercuryBarycenter {} -impl Body for MercuryBarycenter { - fn id(&self) -> NaifId { - NaifId(1i32) - } - fn name(&self) -> &'static str { - "Mercury Barycenter" - } -} -impl Display for MercuryBarycenter { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl PointMass for MercuryBarycenter { - fn gravitational_parameter(&self) -> f64 { - 22031.868551400003f64 - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct VenusBarycenter; -impl Barycenter for VenusBarycenter {} -impl Body for VenusBarycenter { - fn id(&self) -> NaifId { - NaifId(2i32) - } - fn name(&self) -> &'static str { - "Venus Barycenter" - } -} -impl Display for VenusBarycenter { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl PointMass for VenusBarycenter { - fn gravitational_parameter(&self) -> f64 { - 324858.592f64 - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct EarthBarycenter; -impl Barycenter for EarthBarycenter {} -impl Body for EarthBarycenter { - fn id(&self) -> NaifId { - NaifId(3i32) - } - fn name(&self) -> &'static str { - "Earth Barycenter" - } -} -impl Display for EarthBarycenter { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl PointMass for EarthBarycenter { - fn gravitational_parameter(&self) -> f64 { - 403503.2356254802f64 - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct MarsBarycenter; -impl Barycenter for MarsBarycenter {} -impl Body for MarsBarycenter { - fn id(&self) -> NaifId { - NaifId(4i32) - } - fn name(&self) -> &'static str { - "Mars Barycenter" - } -} -impl Display for MarsBarycenter { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl PointMass for MarsBarycenter { - fn gravitational_parameter(&self) -> f64 { - 42828.3758157561f64 - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct JupiterBarycenter; -impl Barycenter for JupiterBarycenter {} -impl Body for JupiterBarycenter { - fn id(&self) -> NaifId { - NaifId(5i32) - } - fn name(&self) -> &'static str { - "Jupiter Barycenter" - } -} -impl Display for JupiterBarycenter { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl PointMass for JupiterBarycenter { - fn gravitational_parameter(&self) -> f64 { - 126712764.09999998f64 - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct SaturnBarycenter; -impl Barycenter for SaturnBarycenter {} -impl Body for SaturnBarycenter { - fn id(&self) -> NaifId { - NaifId(6i32) - } - fn name(&self) -> &'static str { - "Saturn Barycenter" - } -} -impl Display for SaturnBarycenter { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl PointMass for SaturnBarycenter { - fn gravitational_parameter(&self) -> f64 { - 37940584.8418f64 - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct UranusBarycenter; -impl Barycenter for UranusBarycenter {} -impl Body for UranusBarycenter { - fn id(&self) -> NaifId { - NaifId(7i32) - } - fn name(&self) -> &'static str { - "Uranus Barycenter" - } -} -impl Display for UranusBarycenter { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl PointMass for UranusBarycenter { - fn gravitational_parameter(&self) -> f64 { - 5794556.3999999985f64 - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct NeptuneBarycenter; -impl Barycenter for NeptuneBarycenter {} -impl Body for NeptuneBarycenter { - fn id(&self) -> NaifId { - NaifId(8i32) - } - fn name(&self) -> &'static str { - "Neptune Barycenter" - } -} -impl Display for NeptuneBarycenter { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl PointMass for NeptuneBarycenter { - fn gravitational_parameter(&self) -> f64 { - 6836527.100580399f64 - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct PlutoBarycenter; -impl Barycenter for PlutoBarycenter {} -impl Body for PlutoBarycenter { - fn id(&self) -> NaifId { - NaifId(9i32) - } - fn name(&self) -> &'static str { - "Pluto Barycenter" - } -} -impl Display for PlutoBarycenter { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl PointMass for PlutoBarycenter { - fn gravitational_parameter(&self) -> f64 { - 975.5f64 - } -} -#[cfg(test)] -#[allow(clippy::approx_constant)] -mod tests { - use super::*; - #[test] - fn test_body_0() { - assert_eq!(SolarSystemBarycenter.id(), NaifId(0i32)); - assert_eq!(SolarSystemBarycenter.name(), "Solar System Barycenter"); - assert_eq!( - format!("{}", SolarSystemBarycenter), - "Solar System Barycenter" - ); - } - #[test] - fn test_body_1() { - assert_eq!(MercuryBarycenter.id(), NaifId(1i32)); - assert_eq!(MercuryBarycenter.name(), "Mercury Barycenter"); - assert_eq!(format!("{}", MercuryBarycenter), "Mercury Barycenter"); - } - #[test] - fn test_point_mass_1() { - assert_eq!( - MercuryBarycenter.gravitational_parameter(), - 22031.868551400003f64 - ); - } - #[test] - fn test_body_2() { - assert_eq!(VenusBarycenter.id(), NaifId(2i32)); - assert_eq!(VenusBarycenter.name(), "Venus Barycenter"); - assert_eq!(format!("{}", VenusBarycenter), "Venus Barycenter"); - } - #[test] - fn test_point_mass_2() { - assert_eq!(VenusBarycenter.gravitational_parameter(), 324858.592f64); - } - #[test] - fn test_body_3() { - assert_eq!(EarthBarycenter.id(), NaifId(3i32)); - assert_eq!(EarthBarycenter.name(), "Earth Barycenter"); - assert_eq!(format!("{}", EarthBarycenter), "Earth Barycenter"); - } - #[test] - fn test_point_mass_3() { - assert_eq!( - EarthBarycenter.gravitational_parameter(), - 403503.2356254802f64 - ); - } - #[test] - fn test_body_4() { - assert_eq!(MarsBarycenter.id(), NaifId(4i32)); - assert_eq!(MarsBarycenter.name(), "Mars Barycenter"); - assert_eq!(format!("{}", MarsBarycenter), "Mars Barycenter"); - } - #[test] - fn test_point_mass_4() { - assert_eq!( - MarsBarycenter.gravitational_parameter(), - 42828.3758157561f64 - ); - } - #[test] - fn test_body_5() { - assert_eq!(JupiterBarycenter.id(), NaifId(5i32)); - assert_eq!(JupiterBarycenter.name(), "Jupiter Barycenter"); - assert_eq!(format!("{}", JupiterBarycenter), "Jupiter Barycenter"); - } - #[test] - fn test_point_mass_5() { - assert_eq!( - JupiterBarycenter.gravitational_parameter(), - 126712764.09999998f64 - ); - } - #[test] - fn test_body_6() { - assert_eq!(SaturnBarycenter.id(), NaifId(6i32)); - assert_eq!(SaturnBarycenter.name(), "Saturn Barycenter"); - assert_eq!(format!("{}", SaturnBarycenter), "Saturn Barycenter"); - } - #[test] - fn test_point_mass_6() { - assert_eq!(SaturnBarycenter.gravitational_parameter(), 37940584.8418f64); - } - #[test] - fn test_body_7() { - assert_eq!(UranusBarycenter.id(), NaifId(7i32)); - assert_eq!(UranusBarycenter.name(), "Uranus Barycenter"); - assert_eq!(format!("{}", UranusBarycenter), "Uranus Barycenter"); - } - #[test] - fn test_point_mass_7() { - assert_eq!( - UranusBarycenter.gravitational_parameter(), - 5794556.3999999985f64 - ); - } - #[test] - fn test_body_8() { - assert_eq!(NeptuneBarycenter.id(), NaifId(8i32)); - assert_eq!(NeptuneBarycenter.name(), "Neptune Barycenter"); - assert_eq!(format!("{}", NeptuneBarycenter), "Neptune Barycenter"); - } - #[test] - fn test_point_mass_8() { - assert_eq!( - NeptuneBarycenter.gravitational_parameter(), - 6836527.100580399f64 - ); - } - #[test] - fn test_body_9() { - assert_eq!(PlutoBarycenter.id(), NaifId(9i32)); - assert_eq!(PlutoBarycenter.name(), "Pluto Barycenter"); - assert_eq!(format!("{}", PlutoBarycenter), "Pluto Barycenter"); - } - #[test] - fn test_point_mass_9() { - assert_eq!(PlutoBarycenter.gravitational_parameter(), 975.5f64); - } -} diff --git a/crates/lox-bodies/src/generated/minor.rs b/crates/lox-bodies/src/generated/minor.rs deleted file mode 100644 index d791ec80..00000000 --- a/crates/lox-bodies/src/generated/minor.rs +++ /dev/null @@ -1,1597 +0,0 @@ -/* - * 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() - ) - } -} diff --git a/crates/lox-bodies/src/generated/planets.rs b/crates/lox-bodies/src/generated/planets.rs deleted file mode 100644 index f7328e35..00000000 --- a/crates/lox-bodies/src/generated/planets.rs +++ /dev/null @@ -1,1851 +0,0 @@ -/* - * 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, NaifId, NutationPrecessionCoefficients, Planet, PointMass, - PolynomialCoefficients, RotationalElements, Spheroid, -}; -use std::fmt::{Display, Formatter}; -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Mercury; -impl Planet for Mercury {} -impl Body for Mercury { - fn id(&self) -> NaifId { - NaifId(199i32) - } - fn name(&self) -> &'static str { - "Mercury" - } -} -impl Display for Mercury { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Mercury { - fn polar_radius(&self) -> f64 { - 2438.26f64 - } - fn mean_radius(&self) -> f64 { - 2439.7733333333335f64 - } -} -impl Spheroid for Mercury { - fn equatorial_radius(&self) -> f64 { - 2440.53f64 - } -} -impl PointMass for Mercury { - fn gravitational_parameter(&self) -> f64 { - 22031.868551400003f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Mercury { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 3.0506799486005773f64, - 6.101359897201155f64, - 2.868854538622146f64, - 5.919534488968053f64, - 2.6870291303890443f64, - ] as &[f64], - &[ - 2608.7878923240937f64, - 5217.575784648187f64, - 7826.363676972282f64, - 10435.151569296375f64, - 13043.939461620466f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.904554967017021f64, - -0.0005724679946541401f64, - 0f64, - &[0f64, 0f64, 0f64, 0f64, 0f64] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.0719026867585775f64, - -0.00008552113334772214f64, - 0f64, - &[0f64, 0f64, 0f64, 0f64, 0f64] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 5.752584270622286f64, - 0.10713722462923113f64, - 0f64, - &[ - 0.0001862714861495712f64, - -0.000019601618296223117f64, - -0.00000192684349420174f64, - -0.00000044313909708136026f64, - -0.00000009965830028887623f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Venus; -impl Planet for Venus {} -impl Body for Venus { - fn id(&self) -> NaifId { - NaifId(299i32) - } - fn name(&self) -> &'static str { - "Venus" - } -} -impl Display for Venus { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Venus { - fn polar_radius(&self) -> f64 { - 6051.8f64 - } - fn mean_radius(&self) -> f64 { - 6051.8f64 - } -} -impl Spheroid for Venus { - fn equatorial_radius(&self) -> f64 { - 6051.8f64 - } -} -impl PointMass for Venus { - fn gravitational_parameter(&self) -> f64 { - 324858.592f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Venus { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - (&[] as &[f64], &[] as &[f64]) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - (4.760560067739733f64, 0f64, 0f64, &[] as &[f64]) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - (1.1721631256393916f64, 0f64, 0f64, &[] as &[f64]) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 2.7960174616949156f64, - -0.025854762996317376f64, - 0f64, - &[] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Earth; -impl Planet for Earth {} -impl Body for Earth { - fn id(&self) -> NaifId { - NaifId(399i32) - } - fn name(&self) -> &'static str { - "Earth" - } -} -impl Display for Earth { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Earth { - fn polar_radius(&self) -> f64 { - 6356.7519f64 - } - fn mean_radius(&self) -> f64 { - 6371.008366666666f64 - } -} -impl Spheroid for Earth { - fn equatorial_radius(&self) -> f64 { - 6378.1366f64 - } -} -impl PointMass for Earth { - fn gravitational_parameter(&self) -> f64 { - 398600.43550702266f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Earth { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.1824469631563095f64, - 4.364876473020098f64, - 4.537995681525416f64, - 3.0826877913349846f64, - 6.240058221362807f64, - 5.438253962996612f64, - 2.355548718369107f64, - 4.827877416989155f64, - 0.5973563897875792f64, - 0.2641381289968218f64, - 2.0899096062155698f64, - 4.188109526378113f64, - 0.4372573375021394f64, - ] as &[f64], - &[ - -33.781483888495835f64, - -67.56296777699167f64, - 8294.909972626925f64, - 8504.459388212737f64, - 628.3019668015924f64, - 16833.15084472816f64, - 8328.69145651542f64, - 209.54947933396397f64, - 1114.6285779726247f64, - -101.3444516654875f64, - 2.301053255936537f64, - 104.77473966698199f64, - 8261.12848873843f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - (0f64, -0.011187560505283653f64, 0f64, &[] as &[f64]) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.5707963267948966f64, - -0.009721483933608416f64, - 0f64, - &[] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 3.3186912127896577f64, - 6.3003876824396166f64, - 0f64, - &[] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Mars; -impl Planet for Mars {} -impl Body for Mars { - fn id(&self) -> NaifId { - NaifId(499i32) - } - fn name(&self) -> &'static str { - "Mars" - } -} -impl Display for Mars { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Mars { - fn polar_radius(&self) -> f64 { - 3376.2f64 - } - fn mean_radius(&self) -> f64 { - 3389.5266666666666f64 - } -} -impl Spheroid for Mars { - fn equatorial_radius(&self) -> f64 { - 3396.19f64 - } -} -impl PointMass for Mars { - fn gravitational_parameter(&self) -> f64 { - 42828.37362069909f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Mars { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 3.328804809897935f64, - 0f64, - 555.6129894920322f64, - 5.809517398292802f64, - 0f64, - 668.125936040531f64, - 3.3097152567180146f64, - 0.22186491448462606f64, - 11.523153020184504f64, - 4.032588225058434f64, - 0f64, - 23.047098122619843f64, - 3.8045796985836846f64, - 0f64, - 334.05316148477937f64, - 3.4730520762801462f64, - 0f64, - 668.1268926511307f64, - 4.357448194643978f64, - 0f64, - 1336.235189496269f64, - 1.3857704297725961f64, - 0f64, - 334.054984682245f64, - 0.751510868094019f64, - 0f64, - 1002.1811764929237f64, - 1.3871248750853138f64, - 0f64, - 0.008801023466045386f64, - 2.252727410236719f64, - 0f64, - 668.130317528175f64, - 0.9890544553471146f64, - 0f64, - 1336.2285297823557f64, - 1.8289772979888115f64, - 0f64, - 0.008801023466045386f64, - ] as &[f64], - &[ - 277.80594525842264f64, - 0.37470342287773584f64, - 0f64, - 334.05422022489097f64, - 6.892873571600945f64, - 0f64, - 719340.2120445863f64, - 2.120032883264378f64, - 0f64, - 11.536473384554899f64, - 4.387288948439982f64, - 0f64, - 668.1113614443373f64, - 3.424288764152381f64, - 0f64, - 334.0469780000094f64, - 3.9495523217086292f64, - 0f64, - 1002.1807129125305f64, - 4.645778664015252f64, - 0f64, - 0.008801023466045386f64, - 2.136869016190709f64, - 0f64, - 668.1273150051017f64, - 1.0064158213753553f64, - 0f64, - 1336.2354112473317f64, - 2.9029314796567682f64, - 0f64, - 334.05659172556966f64, - 0.6344650043848296f64, - 0f64, - 1002.1842799588599f64, - 1.1757236496733376f64, - 0f64, - 1670.2877519268022f64, - 1.664898441223219f64, - 0f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 5.5373921900749785f64, - -0.001907216743164288f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.000001186823891356144f64, - 0.000004153883619746505f64, - 0.0000009075712110370513f64, - 0.00000015707963267948966f64, - 0.007313924403529878f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 0.9500266243444937f64, - -0.0010170216810942417f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.000000890117918517108f64, - 0.000002460914245312005f64, - 0.0000005410520681182422f64, - 0.00000008726646259971648f64, - 0.02777297060138025f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 3.0726497570349416f64, - 6.12422041248567f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.000002530727415391778f64, - 0.0000027401669256310974f64, - 0.0000006981317007977319f64, - 0.000000017453292519943295f64, - 0.000000017453292519943295f64, - 0.010202182516192693f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Jupiter; -impl Planet for Jupiter {} -impl Body for Jupiter { - fn id(&self) -> NaifId { - NaifId(599i32) - } - fn name(&self) -> &'static str { - "Jupiter" - } -} -impl Display for Jupiter { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Jupiter { - fn polar_radius(&self) -> f64 { - 66854f64 - } - fn mean_radius(&self) -> f64 { - 69946f64 - } -} -impl Spheroid for Jupiter { - fn equatorial_radius(&self) -> f64 { - 71492f64 - } -} -impl PointMass for Jupiter { - fn gravitational_parameter(&self) -> f64 { - 126686531.9003704f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Jupiter { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.6784701644349695f64, - -0.00011342894808711148f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0000020420352248333656f64, - 0.000016371188383706813f64, - 0.000024993114888558796f64, - 0.0000005235987755982989f64, - 0.00003752457891787809f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.1256553894213766f64, - 0.00004211479485062318f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0000008726646259971648f64, - 0.000007051130178057092f64, - 0.000010768681484805013f64, - -0.00000022689280275926283f64, - 0.00001616174887346749f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 4.973315703557842f64, - 15.193719457141356f64, - 0f64, - &[ - 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Saturn; -impl Planet for Saturn {} -impl Body for Saturn { - fn id(&self) -> NaifId { - NaifId(699i32) - } - fn name(&self) -> &'static str { - "Saturn" - } -} -impl Display for Saturn { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Saturn { - fn polar_radius(&self) -> f64 { - 54364f64 - } - fn mean_radius(&self) -> f64 { - 58300f64 - } -} -impl Spheroid for Saturn { - fn equatorial_radius(&self) -> f64 { - 60268f64 - } -} -impl PointMass for Saturn { - fn gravitational_parameter(&self) -> f64 { - 37931206.23436167f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Saturn { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7084116900919784f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.457995697238503f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 0.6789330790257941f64, - 14.151023151973554f64, - 0f64, - &[] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Uranus; -impl Planet for Uranus {} -impl Body for Uranus { - fn id(&self) -> NaifId { - NaifId(799i32) - } - fn name(&self) -> &'static str { - "Uranus" - } -} -impl Display for Uranus { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Uranus { - fn polar_radius(&self) -> f64 { - 24973f64 - } - fn mean_radius(&self) -> f64 { - 25363.666666666668f64 - } -} -impl Spheroid for Uranus { - fn equatorial_radius(&self) -> f64 { - 25559f64 - } -} -impl PointMass for Uranus { - fn gravitational_parameter(&self) -> f64 { - 5793951.256527211f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Uranus { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - (4.4909241515991285f64, 0f64, 0f64, &[] as &[f64]) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - (-0.2648537139901395f64, 0f64, 0f64, &[] as &[f64]) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 3.557155548489643f64, - -8.746893698960328f64, - 0f64, - &[] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Neptune; -impl Planet for Neptune {} -impl Body for Neptune { - fn id(&self) -> NaifId { - NaifId(899i32) - } - fn name(&self) -> &'static str { - "Neptune" - } -} -impl Display for Neptune { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Neptune { - fn polar_radius(&self) -> f64 { - 24341f64 - } - fn mean_radius(&self) -> f64 { - 24623f64 - } -} -impl Spheroid for Neptune { - fn equatorial_radius(&self) -> f64 { - 24764f64 - } -} -impl PointMass for Neptune { - fn gravitational_parameter(&self) -> f64 { - 6835103.145462294f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Neptune { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64, - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 5.224817648770225f64, - 0f64, - 0f64, - &[ - 0.012217304763960306f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7585200929167356f64, - 0f64, - 0f64, - &[ - -0.00890117918517108f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 4.362939157550385f64, - 9.444670799468602f64, - 0f64, - &[ - -0.008377580409572781f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Pluto; -impl Planet for Pluto {} -impl Body for Pluto { - fn id(&self) -> NaifId { - NaifId(999i32) - } - fn name(&self) -> &'static str { - "Pluto" - } -} -impl Display for Pluto { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Pluto { - fn polar_radius(&self) -> f64 { - 1188.3f64 - } - fn mean_radius(&self) -> f64 { - 1188.3f64 - } -} -impl Spheroid for Pluto { - fn equatorial_radius(&self) -> f64 { - 1188.3f64 - } -} -impl PointMass for Pluto { - fn gravitational_parameter(&self) -> f64 { - 869.6138177608748f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Pluto { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - (&[] as &[f64], &[] as &[f64]) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - (2.3211657321048187f64, 0f64, 0f64, &[] as &[f64]) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - (-0.10756464180041053f64, 0f64, 0f64, &[] as &[f64]) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 5.283024379324235f64, - 0.9837115923543857f64, - 0f64, - &[] as &[f64], - ) - } -} -#[cfg(test)] -#[allow(clippy::approx_constant)] -mod tests { - use super::*; - #[test] - fn test_body_199() { - assert_eq!(Mercury.id(), NaifId(199i32)); - assert_eq!(Mercury.name(), "Mercury"); - assert_eq!(format!("{}", Mercury), "Mercury"); - } - #[test] - fn test_spheroid_199() { - assert_eq!(Mercury.polar_radius(), 2438.26f64); - assert_eq!(Mercury.mean_radius(), 2439.7733333333335f64); - assert_eq!(Mercury.equatorial_radius(), 2440.53f64); - } - #[test] - fn test_point_mass_199() { - assert_eq!(Mercury.gravitational_parameter(), 22031.868551400003f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_199() { - assert_eq!( - ( - &[ - 3.0506799486005773f64, - 6.101359897201155f64, - 2.868854538622146f64, - 5.919534488968053f64, - 2.6870291303890443f64 - ] as &[f64], - &[ - 2608.7878923240937f64, - 5217.575784648187f64, - 7826.363676972282f64, - 10435.151569296375f64, - 13043.939461620466f64 - ] as &[f64] - ), - Mercury.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_199() { - assert_eq!( - ( - 4.904554967017021f64, - -0.0005724679946541401f64, - 0f64, - &[0f64, 0f64, 0f64, 0f64, 0f64] as &[f64] - ), - Mercury.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_199() { - assert_eq!( - ( - 1.0719026867585775f64, - -0.00008552113334772214f64, - 0f64, - &[0f64, 0f64, 0f64, 0f64, 0f64] as &[f64] - ), - Mercury.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_199() { - assert_eq!( - ( - 5.752584270622286f64, - 0.10713722462923113f64, - 0f64, - &[ - 0.0001862714861495712f64, - -0.000019601618296223117f64, - -0.00000192684349420174f64, - -0.00000044313909708136026f64, - -0.00000009965830028887623f64 - ] as &[f64] - ), - Mercury.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_299() { - assert_eq!(Venus.id(), NaifId(299i32)); - assert_eq!(Venus.name(), "Venus"); - assert_eq!(format!("{}", Venus), "Venus"); - } - #[test] - fn test_spheroid_299() { - assert_eq!(Venus.polar_radius(), 6051.8f64); - assert_eq!(Venus.mean_radius(), 6051.8f64); - assert_eq!(Venus.equatorial_radius(), 6051.8f64); - } - #[test] - fn test_point_mass_299() { - assert_eq!(Venus.gravitational_parameter(), 324858.592f64); - } - #[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!( - (4.760560067739733f64, 0f64, 0f64, &[] as &[f64]), - Venus.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_299() { - assert_eq!( - (1.1721631256393916f64, 0f64, 0f64, &[] as &[f64]), - Venus.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_299() { - assert_eq!( - ( - 2.7960174616949156f64, - -0.025854762996317376f64, - 0f64, - &[] as &[f64] - ), - Venus.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_399() { - assert_eq!(Earth.id(), NaifId(399i32)); - assert_eq!(Earth.name(), "Earth"); - assert_eq!(format!("{}", Earth), "Earth"); - } - #[test] - fn test_spheroid_399() { - assert_eq!(Earth.polar_radius(), 6356.7519f64); - assert_eq!(Earth.mean_radius(), 6371.008366666666f64); - assert_eq!(Earth.equatorial_radius(), 6378.1366f64); - } - #[test] - fn test_point_mass_399() { - assert_eq!(Earth.gravitational_parameter(), 398600.43550702266f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_399() { - assert_eq!( - ( - &[ - 2.1824469631563095f64, - 4.364876473020098f64, - 4.537995681525416f64, - 3.0826877913349846f64, - 6.240058221362807f64, - 5.438253962996612f64, - 2.355548718369107f64, - 4.827877416989155f64, - 0.5973563897875792f64, - 0.2641381289968218f64, - 2.0899096062155698f64, - 4.188109526378113f64, - 0.4372573375021394f64 - ] as &[f64], - &[ - -33.781483888495835f64, - -67.56296777699167f64, - 8294.909972626925f64, - 8504.459388212737f64, - 628.3019668015924f64, - 16833.15084472816f64, - 8328.69145651542f64, - 209.54947933396397f64, - 1114.6285779726247f64, - -101.3444516654875f64, - 2.301053255936537f64, - 104.77473966698199f64, - 8261.12848873843f64 - ] as &[f64] - ), - Earth.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_399() { - assert_eq!( - (0f64, -0.011187560505283653f64, 0f64, &[] as &[f64]), - Earth.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_399() { - assert_eq!( - ( - 1.5707963267948966f64, - -0.009721483933608416f64, - 0f64, - &[] as &[f64] - ), - Earth.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_399() { - assert_eq!( - ( - 3.3186912127896577f64, - 6.3003876824396166f64, - 0f64, - &[] as &[f64] - ), - Earth.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_499() { - assert_eq!(Mars.id(), NaifId(499i32)); - assert_eq!(Mars.name(), "Mars"); - assert_eq!(format!("{}", Mars), "Mars"); - } - #[test] - fn test_spheroid_499() { - assert_eq!(Mars.polar_radius(), 3376.2f64); - assert_eq!(Mars.mean_radius(), 3389.5266666666666f64); - assert_eq!(Mars.equatorial_radius(), 3396.19f64); - } - #[test] - fn test_point_mass_499() { - assert_eq!(Mars.gravitational_parameter(), 42828.37362069909f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_499() { - assert_eq!( - ( - &[ - 3.328804809897935f64, - 0f64, - 555.6129894920322f64, - 5.809517398292802f64, - 0f64, - 668.125936040531f64, - 3.3097152567180146f64, - 0.22186491448462606f64, - 11.523153020184504f64, - 4.032588225058434f64, - 0f64, - 23.047098122619843f64, - 3.8045796985836846f64, - 0f64, - 334.05316148477937f64, - 3.4730520762801462f64, - 0f64, - 668.1268926511307f64, - 4.357448194643978f64, - 0f64, - 1336.235189496269f64, - 1.3857704297725961f64, - 0f64, - 334.054984682245f64, - 0.751510868094019f64, - 0f64, - 1002.1811764929237f64, - 1.3871248750853138f64, - 0f64, - 0.008801023466045386f64, - 2.252727410236719f64, - 0f64, - 668.130317528175f64, - 0.9890544553471146f64, - 0f64, - 1336.2285297823557f64, - 1.8289772979888115f64, - 0f64, - 0.008801023466045386f64 - ] as &[f64], - &[ - 277.80594525842264f64, - 0.37470342287773584f64, - 0f64, - 334.05422022489097f64, - 6.892873571600945f64, - 0f64, - 719340.2120445863f64, - 2.120032883264378f64, - 0f64, - 11.536473384554899f64, - 4.387288948439982f64, - 0f64, - 668.1113614443373f64, - 3.424288764152381f64, - 0f64, - 334.0469780000094f64, - 3.9495523217086292f64, - 0f64, - 1002.1807129125305f64, - 4.645778664015252f64, - 0f64, - 0.008801023466045386f64, - 2.136869016190709f64, - 0f64, - 668.1273150051017f64, - 1.0064158213753553f64, - 0f64, - 1336.2354112473317f64, - 2.9029314796567682f64, - 0f64, - 334.05659172556966f64, - 0.6344650043848296f64, - 0f64, - 1002.1842799588599f64, - 1.1757236496733376f64, - 0f64, - 1670.2877519268022f64, - 1.664898441223219f64, - 0f64 - ] as &[f64] - ), - Mars.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_499() { - assert_eq!( - ( - 5.5373921900749785f64, - -0.001907216743164288f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.000001186823891356144f64, - 0.000004153883619746505f64, - 0.0000009075712110370513f64, - 0.00000015707963267948966f64, - 0.007313924403529878f64 - ] as &[f64] - ), - Mars.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_499() { - assert_eq!( - ( - 0.9500266243444937f64, - -0.0010170216810942417f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.000000890117918517108f64, - 0.000002460914245312005f64, - 0.0000005410520681182422f64, - 0.00000008726646259971648f64, - 0.02777297060138025f64 - ] as &[f64] - ), - Mars.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_499() { - assert_eq!( - ( - 3.0726497570349416f64, - 6.12422041248567f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.000002530727415391778f64, - 0.0000027401669256310974f64, - 0.0000006981317007977319f64, - 0.000000017453292519943295f64, - 0.000000017453292519943295f64, - 0.010202182516192693f64 - ] as &[f64] - ), - Mars.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_599() { - assert_eq!(Jupiter.id(), NaifId(599i32)); - assert_eq!(Jupiter.name(), "Jupiter"); - assert_eq!(format!("{}", Jupiter), "Jupiter"); - } - #[test] - fn test_spheroid_599() { - assert_eq!(Jupiter.polar_radius(), 66854f64); - assert_eq!(Jupiter.mean_radius(), 69946f64); - assert_eq!(Jupiter.equatorial_radius(), 71492f64); - } - #[test] - fn test_point_mass_599() { - assert_eq!(Jupiter.gravitational_parameter(), 126686531.9003704f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_599() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Jupiter.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_599() { - assert_eq!( - ( - 4.6784701644349695f64, - -0.00011342894808711148f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0000020420352248333656f64, - 0.000016371188383706813f64, - 0.000024993114888558796f64, - 0.0000005235987755982989f64, - 0.00003752457891787809f64 - ] as &[f64] - ), - Jupiter.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_599() { - assert_eq!( - ( - 1.1256553894213766f64, - 0.00004211479485062318f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0000008726646259971648f64, - 0.000007051130178057092f64, - 0.000010768681484805013f64, - -0.00000022689280275926283f64, - 0.00001616174887346749f64 - ] as &[f64] - ), - Jupiter.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_599() { - assert_eq!( - ( - 4.973315703557842f64, - 15.193719457141356f64, - 0f64, - &[ - 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, - 0f64, 0f64 - ] as &[f64] - ), - Jupiter.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_699() { - assert_eq!(Saturn.id(), NaifId(699i32)); - assert_eq!(Saturn.name(), "Saturn"); - assert_eq!(format!("{}", Saturn), "Saturn"); - } - #[test] - fn test_spheroid_699() { - assert_eq!(Saturn.polar_radius(), 54364f64); - assert_eq!(Saturn.mean_radius(), 58300f64); - assert_eq!(Saturn.equatorial_radius(), 60268f64); - } - #[test] - fn test_point_mass_699() { - assert_eq!(Saturn.gravitational_parameter(), 37931206.23436167f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_699() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] as &[f64] - ), - Saturn.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_699() { - assert_eq!( - ( - 0.7084116900919784f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64] - ), - Saturn.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_699() { - assert_eq!( - ( - 1.457995697238503f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64] - ), - Saturn.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_699() { - assert_eq!( - ( - 0.6789330790257941f64, - 14.151023151973554f64, - 0f64, - &[] as &[f64] - ), - Saturn.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_799() { - assert_eq!(Uranus.id(), NaifId(799i32)); - assert_eq!(Uranus.name(), "Uranus"); - assert_eq!(format!("{}", Uranus), "Uranus"); - } - #[test] - fn test_spheroid_799() { - assert_eq!(Uranus.polar_radius(), 24973f64); - assert_eq!(Uranus.mean_radius(), 25363.666666666668f64); - assert_eq!(Uranus.equatorial_radius(), 25559f64); - } - #[test] - fn test_point_mass_799() { - assert_eq!(Uranus.gravitational_parameter(), 5793951.256527211f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_799() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Uranus.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_799() { - assert_eq!( - (4.4909241515991285f64, 0f64, 0f64, &[] as &[f64]), - Uranus.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_799() { - assert_eq!( - (-0.2648537139901395f64, 0f64, 0f64, &[] as &[f64]), - Uranus.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_799() { - assert_eq!( - ( - 3.557155548489643f64, - -8.746893698960328f64, - 0f64, - &[] as &[f64] - ), - Uranus.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_899() { - assert_eq!(Neptune.id(), NaifId(899i32)); - assert_eq!(Neptune.name(), "Neptune"); - assert_eq!(format!("{}", Neptune), "Neptune"); - } - #[test] - fn test_spheroid_899() { - assert_eq!(Neptune.polar_radius(), 24341f64); - assert_eq!(Neptune.mean_radius(), 24623f64); - assert_eq!(Neptune.equatorial_radius(), 24764f64); - } - #[test] - fn test_point_mass_899() { - assert_eq!(Neptune.gravitational_parameter(), 6835103.145462294f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_899() { - assert_eq!( - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64 - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64 - ] as &[f64] - ), - Neptune.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_899() { - assert_eq!( - ( - 5.224817648770225f64, - 0f64, - 0f64, - &[ - 0.012217304763960306f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Neptune.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_899() { - assert_eq!( - ( - 0.7585200929167356f64, - 0f64, - 0f64, - &[ - -0.00890117918517108f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Neptune.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_899() { - assert_eq!( - ( - 4.362939157550385f64, - 9.444670799468602f64, - 0f64, - &[ - -0.008377580409572781f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Neptune.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_999() { - assert_eq!(Pluto.id(), NaifId(999i32)); - assert_eq!(Pluto.name(), "Pluto"); - assert_eq!(format!("{}", Pluto), "Pluto"); - } - #[test] - fn test_spheroid_999() { - assert_eq!(Pluto.polar_radius(), 1188.3f64); - assert_eq!(Pluto.mean_radius(), 1188.3f64); - assert_eq!(Pluto.equatorial_radius(), 1188.3f64); - } - #[test] - fn test_point_mass_999() { - assert_eq!(Pluto.gravitational_parameter(), 869.6138177608748f64); - } - #[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!( - (2.3211657321048187f64, 0f64, 0f64, &[] as &[f64]), - Pluto.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_999() { - assert_eq!( - (-0.10756464180041053f64, 0f64, 0f64, &[] as &[f64]), - Pluto.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_999() { - assert_eq!( - ( - 5.283024379324235f64, - 0.9837115923543857f64, - 0f64, - &[] as &[f64] - ), - Pluto.prime_meridian_coefficients() - ) - } -} diff --git a/crates/lox-bodies/src/generated/satellites.rs b/crates/lox-bodies/src/generated/satellites.rs deleted file mode 100644 index 7fcf76ac..00000000 --- a/crates/lox-bodies/src/generated/satellites.rs +++ /dev/null @@ -1,25773 +0,0 @@ -/* - * 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, NaifId, NutationPrecessionCoefficients, PointMass, PolynomialCoefficients, - RotationalElements, Satellite, TriAxial, -}; -use std::fmt::{Display, Formatter}; -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Moon; -impl Satellite for Moon {} -impl Body for Moon { - fn id(&self) -> NaifId { - NaifId(301i32) - } - fn name(&self) -> &'static str { - "Moon" - } -} -impl Display for Moon { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Moon { - fn polar_radius(&self) -> f64 { - 1737.4f64 - } - fn mean_radius(&self) -> f64 { - 1737.4000000000003f64 - } -} -impl TriAxial for Moon { - fn subplanetary_radius(&self) -> f64 { - 1737.4f64 - } - fn along_orbit_radius(&self) -> f64 { - 1737.4f64 - } -} -impl PointMass for Moon { - fn gravitational_parameter(&self) -> f64 { - 4902.80011845755f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Moon { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.1824469631563095f64, - 4.364876473020098f64, - 4.537995681525416f64, - 3.0826877913349846f64, - 6.240058221362807f64, - 5.438253962996612f64, - 2.355548718369107f64, - 4.827877416989155f64, - 0.5973563897875792f64, - 0.2641381289968218f64, - 2.0899096062155698f64, - 4.188109526378113f64, - 0.4372573375021394f64, - ] as &[f64], - &[ - -33.781483888495835f64, - -67.56296777699167f64, - 8294.909972626925f64, - 8504.459388212737f64, - 628.3019668015924f64, - 16833.15084472816f64, - 8328.69145651542f64, - 209.54947933396397f64, - 1114.6285779726247f64, - -101.3444516654875f64, - 2.301053255936537f64, - 104.77473966698199f64, - 8261.12848873843f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.712299968592838f64, - 0.000054105206811824215f64, - 0f64, - &[ - -0.06769608569710406f64, - -0.0021013764194011725f64, - 0.0012217304763960308f64, - -0.0003001966313430247f64, - 0f64, - 0.0001256637061435917f64, - 0f64, - 0f64, - 0f64, - -0.00009075712110370513f64, - 0f64, - 0f64, - 0.00007504915783575618f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.161328121643011f64, - 0.00022689280275926284f64, - 0f64, - &[ - 0.02691123173650057f64, - 0.0004171336912266448f64, - -0.00048520153205442357f64, - 0.0001186823891356144f64, - 0f64, - -0.00005061454830783555f64, - 0.000015707963267948964f64, - 0f64, - 0f64, - 0.000013962634015954637f64, - 0f64, - 0f64, - -0.000015707963267948964f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 0.668832858644503f64, - 0.22997083313948888f64, - -0.000000000000024434609527920614f64, - &[ - 0.06215117466351808f64, - 0.00210835773640915f64, - -0.0011205013797803594f64, - 0.0002757620218151041f64, - 0.0004398229715025711f64, - -0.00011519173063162575f64, - -0.00008203047484373349f64, - -0.00008028514559173915f64, - 0.000048869219055841225f64, - 0.00009075712110370513f64, - 0.00006981317007977319f64, - 0.00003316125578789226f64, - -0.0000767944870877505f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Phobos; -impl Satellite for Phobos {} -impl Body for Phobos { - fn id(&self) -> NaifId { - NaifId(401i32) - } - fn name(&self) -> &'static str { - "Phobos" - } -} -impl Display for Phobos { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Phobos { - fn polar_radius(&self) -> f64 { - 9.1f64 - } - fn mean_radius(&self) -> f64 { - 11.166666666666666f64 - } -} -impl TriAxial for Phobos { - fn subplanetary_radius(&self) -> f64 { - 13f64 - } - fn along_orbit_radius(&self) -> f64 { - 11.4f64 - } -} -impl PointMass for Phobos { - fn gravitational_parameter(&self) -> f64 { - 0.0007087546066894452f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Phobos { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 3.328804809897935f64, - 0f64, - 555.6129894920322f64, - 5.809517398292802f64, - 0f64, - 668.125936040531f64, - 3.3097152567180146f64, - 0.22186491448462606f64, - 11.523153020184504f64, - 4.032588225058434f64, - 0f64, - 23.047098122619843f64, - 3.8045796985836846f64, - 0f64, - 334.05316148477937f64, - 3.4730520762801462f64, - 0f64, - 668.1268926511307f64, - 4.357448194643978f64, - 0f64, - 1336.235189496269f64, - 1.3857704297725961f64, - 0f64, - 334.054984682245f64, - 0.751510868094019f64, - 0f64, - 1002.1811764929237f64, - 1.3871248750853138f64, - 0f64, - 0.008801023466045386f64, - 2.252727410236719f64, - 0f64, - 668.130317528175f64, - 0.9890544553471146f64, - 0f64, - 1336.2285297823557f64, - 1.8289772979888115f64, - 0f64, - 0.008801023466045386f64, - ] as &[f64], - &[ - 277.80594525842264f64, - 0.37470342287773584f64, - 0f64, - 334.05422022489097f64, - 6.892873571600945f64, - 0f64, - 719340.2120445863f64, - 2.120032883264378f64, - 0f64, - 11.536473384554899f64, - 4.387288948439982f64, - 0f64, - 668.1113614443373f64, - 3.424288764152381f64, - 0f64, - 334.0469780000094f64, - 3.9495523217086292f64, - 0f64, - 1002.1807129125305f64, - 4.645778664015252f64, - 0f64, - 0.008801023466045386f64, - 2.136869016190709f64, - 0f64, - 668.1273150051017f64, - 1.0064158213753553f64, - 0f64, - 1336.2354112473317f64, - 2.9029314796567682f64, - 0f64, - 334.05659172556966f64, - 0.6344650043848296f64, - 0f64, - 1002.1842799588599f64, - 1.1757236496733376f64, - 0f64, - 1670.2877519268022f64, - 1.664898441223219f64, - 0f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 5.544399941316208f64, - -0.001892691938596266f64, - 0f64, - &[ - -0.031141630416121578f64, - 0.00038621064567151f64, - -0.00017946365486924213f64, - -0.00008300698656022431f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 0.9230395870244597f64, - -0.0010707081834185127f64, - 0f64, - &[ - -0.018765175709923063f64, - 0.00011669725164439606f64, - -0.00011322648989388013f64, - 0.000049144282945955534f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 0.6141419961301966f64, - 19.702057793318815f64, - 0.00000000016643698911600935f64, - &[ - 0.02485728795564792f64, - -0.0003968499982587423f64, - 0.0000716825922415843f64, - 0.00011029852554073445f64, - -0.019949113350295186f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Deimos; -impl Satellite for Deimos {} -impl Body for Deimos { - fn id(&self) -> NaifId { - NaifId(402i32) - } - fn name(&self) -> &'static str { - "Deimos" - } -} -impl Display for Deimos { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Deimos { - fn polar_radius(&self) -> f64 { - 5.1f64 - } - fn mean_radius(&self) -> f64 { - 6.3f64 - } -} -impl TriAxial for Deimos { - fn subplanetary_radius(&self) -> f64 { - 7.8f64 - } - fn along_orbit_radius(&self) -> f64 { - 6f64 - } -} -impl PointMass for Deimos { - fn gravitational_parameter(&self) -> f64 { - 0.00009615569648120313f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Deimos { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 3.328804809897935f64, - 0f64, - 555.6129894920322f64, - 5.809517398292802f64, - 0f64, - 668.125936040531f64, - 3.3097152567180146f64, - 0.22186491448462606f64, - 11.523153020184504f64, - 4.032588225058434f64, - 0f64, - 23.047098122619843f64, - 3.8045796985836846f64, - 0f64, - 334.05316148477937f64, - 3.4730520762801462f64, - 0f64, - 668.1268926511307f64, - 4.357448194643978f64, - 0f64, - 1336.235189496269f64, - 1.3857704297725961f64, - 0f64, - 334.054984682245f64, - 0.751510868094019f64, - 0f64, - 1002.1811764929237f64, - 1.3871248750853138f64, - 0f64, - 0.008801023466045386f64, - 2.252727410236719f64, - 0f64, - 668.130317528175f64, - 0.9890544553471146f64, - 0f64, - 1336.2285297823557f64, - 1.8289772979888115f64, - 0f64, - 0.008801023466045386f64, - ] as &[f64], - &[ - 277.80594525842264f64, - 0.37470342287773584f64, - 0f64, - 334.05422022489097f64, - 6.892873571600945f64, - 0f64, - 719340.2120445863f64, - 2.120032883264378f64, - 0f64, - 11.536473384554899f64, - 4.387288948439982f64, - 0f64, - 668.1113614443373f64, - 3.424288764152381f64, - 0f64, - 334.0469780000094f64, - 3.9495523217086292f64, - 0f64, - 1002.1807129125305f64, - 4.645778664015252f64, - 0f64, - 0.008801023466045386f64, - 2.136869016190709f64, - 0f64, - 668.1273150051017f64, - 1.0064158213753553f64, - 0f64, - 1336.2354112473317f64, - 2.9029314796567682f64, - 0f64, - 334.05659172556966f64, - 0.6344650043848296f64, - 0f64, - 1002.1842799588599f64, - 1.1757236496733376f64, - 0f64, - 1670.2877519268022f64, - 1.664898441223219f64, - 0f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 5.526708263174914f64, - -0.0018357397507085887f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.05396867424229676f64, - 0.004010877798556321f64, - 0.0011202666329959662f64, - 0.00044218562371099577f64, - 0.00013590791618817245f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 0.9339242922383507f64, - -0.0010435487658623783f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.032102888827614605f64, - 0.002500240004017941f64, - 0.00033360380402252296f64, - -0.0002587607695714273f64, - 0.00003358537079612689f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 1.3857797243489947f64, - 4.977013864082068f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.047814137677880446f64, - -0.006975837721323607f64, - -0.0011455047921115052f64, - -0.0005084039391304362f64, - 0.0002965593651818685f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Io; -impl Satellite for Io {} -impl Body for Io { - fn id(&self) -> NaifId { - NaifId(501i32) - } - fn name(&self) -> &'static str { - "Io" - } -} -impl Display for Io { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Io { - fn polar_radius(&self) -> f64 { - 1815.7f64 - } - fn mean_radius(&self) -> f64 { - 1821.5f64 - } -} -impl TriAxial for Io { - fn subplanetary_radius(&self) -> f64 { - 1829.4f64 - } - fn along_orbit_radius(&self) -> f64 { - 1819.4f64 - } -} -impl PointMass for Io { - fn gravitational_parameter(&self) -> f64 { - 5959.915466180539f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Io { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.678355059970801f64, - -0.00015707963267948965f64, - 0f64, - &[ - 0f64, - 0f64, - 0.0016406094968746698f64, - 0.0004188790204786391f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.1257373675363425f64, - 0.00005235987755982989f64, - 0f64, - &[ - 0f64, - 0f64, - 0.0006981317007977319f64, - 0.00019198621771937625f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 3.4974652880714365f64, - 3.551552235248627f64, - 0f64, - &[ - 0f64, - 0f64, - -0.0014835298641951802f64, - -0.0003839724354387525f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Europa; -impl Satellite for Europa {} -impl Body for Europa { - fn id(&self) -> NaifId { - NaifId(502i32) - } - fn name(&self) -> &'static str { - "Europa" - } -} -impl Display for Europa { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Europa { - fn polar_radius(&self) -> f64 { - 1559.5f64 - } - fn mean_radius(&self) -> f64 { - 1560.8f64 - } -} -impl TriAxial for Europa { - fn subplanetary_radius(&self) -> f64 { - 1562.6f64 - } - fn along_orbit_radius(&self) -> f64 { - 1560.3f64 - } -} -impl PointMass for Europa { - fn gravitational_parameter(&self) -> f64 { - 3202.712099607295f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Europa { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.678878658746398f64, - -0.00015707963267948965f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0.01895427567665842f64, - 0.0010471975511965976f64, - 0.0002617993877991494f64, - 0.00015707963267948965f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.125911900461542f64, - 0.00005235987755982989f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0.008168140899333463f64, - 0.0004537856055185257f64, - 0.00012217304763960306f64, - 0.00003490658503988659f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 0.6287025031533974f64, - 1.7693227033738699f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - -0.01710422666954443f64, - -0.0009424777960769379f64, - -0.0002443460952792061f64, - -0.00013962634015954637f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Ganymede; -impl Satellite for Ganymede {} -impl Body for Ganymede { - fn id(&self) -> NaifId { - NaifId(503i32) - } - fn name(&self) -> &'static str { - "Ganymede" - } -} -impl Display for Ganymede { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Ganymede { - fn polar_radius(&self) -> f64 { - 2631.2f64 - } - fn mean_radius(&self) -> f64 { - 2631.2f64 - } -} -impl TriAxial for Ganymede { - fn subplanetary_radius(&self) -> f64 { - 2631.2f64 - } - fn along_orbit_radius(&self) -> f64 { - 2631.2f64 - } -} -impl PointMass for Ganymede { - fn gravitational_parameter(&self) -> f64 { - 9887.832752719638f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Ganymede { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.680973053848792f64, - -0.00015707963267948965f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - -0.0006457718232379018f64, - 0.0075223690760955605f64, - 0.0015882496193148398f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.1269590980127384f64, - 0.00005235987755982989f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - -0.00027925268031909274f64, - 0.003246312408709453f64, - 0.0006806784082777885f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7690618815987814f64, - 0.8782079330731682f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0.0005759586531581288f64, - -0.006789330790257942f64, - -0.0014311699866353504f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Callisto; -impl Satellite for Callisto {} -impl Body for Callisto { - fn id(&self) -> NaifId { - NaifId(504i32) - } - fn name(&self) -> &'static str { - "Callisto" - } -} -impl Display for Callisto { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Callisto { - fn polar_radius(&self) -> f64 { - 2410.3f64 - } - fn mean_radius(&self) -> f64 { - 2410.3f64 - } -} -impl TriAxial for Callisto { - fn subplanetary_radius(&self) -> f64 { - 2410.3f64 - } - fn along_orbit_radius(&self) -> f64 { - 2410.3f64 - } -} -impl PointMass for Callisto { - fn gravitational_parameter(&self) -> f64 { - 7179.283402579837f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Callisto { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.690048765959163f64, - -0.00015707963267948965f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - -0.001186823891356144f64, - 0.010297442586766544f64, - 0f64, - 0.00017453292519943296f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.1314969540679238f64, - 0.00005235987755982989f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - -0.0005061454830783556f64, - 0.004433136300065597f64, - 0f64, - -0.00006981317007977319f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 4.529303941850484f64, - 0.37648622085811195f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0.001064650843716541f64, - -0.009302604913129777f64, - 0f64, - -0.00015707963267948965f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Amalthea; -impl Satellite for Amalthea {} -impl Body for Amalthea { - fn id(&self) -> NaifId { - NaifId(505i32) - } - fn name(&self) -> &'static str { - "Amalthea" - } -} -impl Display for Amalthea { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Amalthea { - fn polar_radius(&self) -> f64 { - 64f64 - } - fn mean_radius(&self) -> f64 { - 87.33333333333333f64 - } -} -impl TriAxial for Amalthea { - fn subplanetary_radius(&self) -> f64 { - 125f64 - } - fn along_orbit_radius(&self) -> f64 { - 73f64 - } -} -impl PointMass for Amalthea { - fn gravitational_parameter(&self) -> f64 { - 0.1645634534798259f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Amalthea { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.678355059970801f64, - -0.00015707963267948965f64, - 0f64, - &[ - -0.014660765716752368f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.00017453292519943296f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.125562834611143f64, - 0.00005235987755982989f64, - 0f64, - &[ - -0.006283185307179586f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 4.043404278095263f64, - 12.612298185680531f64, - 0f64, - &[ - 0.013264502315156905f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.00017453292519943296f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Himalia; -impl Satellite for Himalia {} -impl Body for Himalia { - fn id(&self) -> NaifId { - NaifId(506i32) - } - fn name(&self) -> &'static str { - "Himalia" - } -} -impl Display for Himalia { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Himalia { - fn polar_radius(&self) -> f64 { - 85f64 - } - fn mean_radius(&self) -> f64 { - 85f64 - } -} -impl TriAxial for Himalia { - fn subplanetary_radius(&self) -> f64 { - 85f64 - } - fn along_orbit_radius(&self) -> f64 { - 85f64 - } -} -impl PointMass for Himalia { - fn gravitational_parameter(&self) -> f64 { - 0.1515524299611265f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Himalia { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Elara; -impl Body for Elara { - fn id(&self) -> NaifId { - NaifId(507i32) - } - fn name(&self) -> &'static str { - "Elara" - } -} -impl Display for Elara { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Elara { - fn polar_radius(&self) -> f64 { - 40f64 - } - fn mean_radius(&self) -> f64 { - 40f64 - } -} -impl TriAxial for Elara { - fn subplanetary_radius(&self) -> f64 { - 40f64 - } - fn along_orbit_radius(&self) -> f64 { - 40f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Elara { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Pasiphae; -impl Body for Pasiphae { - fn id(&self) -> NaifId { - NaifId(508i32) - } - fn name(&self) -> &'static str { - "Pasiphae" - } -} -impl Display for Pasiphae { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Pasiphae { - fn polar_radius(&self) -> f64 { - 18f64 - } - fn mean_radius(&self) -> f64 { - 18f64 - } -} -impl TriAxial for Pasiphae { - fn subplanetary_radius(&self) -> f64 { - 18f64 - } - fn along_orbit_radius(&self) -> f64 { - 18f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Pasiphae { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Sinope; -impl Body for Sinope { - fn id(&self) -> NaifId { - NaifId(509i32) - } - fn name(&self) -> &'static str { - "Sinope" - } -} -impl Display for Sinope { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Sinope { - fn polar_radius(&self) -> f64 { - 14f64 - } - fn mean_radius(&self) -> f64 { - 14f64 - } -} -impl TriAxial for Sinope { - fn subplanetary_radius(&self) -> f64 { - 14f64 - } - fn along_orbit_radius(&self) -> f64 { - 14f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Sinope { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Lysithea; -impl Body for Lysithea { - fn id(&self) -> NaifId { - NaifId(510i32) - } - fn name(&self) -> &'static str { - "Lysithea" - } -} -impl Display for Lysithea { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Lysithea { - fn polar_radius(&self) -> f64 { - 12f64 - } - fn mean_radius(&self) -> f64 { - 12f64 - } -} -impl TriAxial for Lysithea { - fn subplanetary_radius(&self) -> f64 { - 12f64 - } - fn along_orbit_radius(&self) -> f64 { - 12f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Lysithea { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Carme; -impl Body for Carme { - fn id(&self) -> NaifId { - NaifId(511i32) - } - fn name(&self) -> &'static str { - "Carme" - } -} -impl Display for Carme { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Carme { - fn polar_radius(&self) -> f64 { - 15f64 - } - fn mean_radius(&self) -> f64 { - 15f64 - } -} -impl TriAxial for Carme { - fn subplanetary_radius(&self) -> f64 { - 15f64 - } - fn along_orbit_radius(&self) -> f64 { - 15f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Carme { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Ananke; -impl Body for Ananke { - fn id(&self) -> NaifId { - NaifId(512i32) - } - fn name(&self) -> &'static str { - "Ananke" - } -} -impl Display for Ananke { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Ananke { - fn polar_radius(&self) -> f64 { - 10f64 - } - fn mean_radius(&self) -> f64 { - 10f64 - } -} -impl TriAxial for Ananke { - fn subplanetary_radius(&self) -> f64 { - 10f64 - } - fn along_orbit_radius(&self) -> f64 { - 10f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Ananke { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Leda; -impl Body for Leda { - fn id(&self) -> NaifId { - NaifId(513i32) - } - fn name(&self) -> &'static str { - "Leda" - } -} -impl Display for Leda { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Leda { - fn polar_radius(&self) -> f64 { - 5f64 - } - fn mean_radius(&self) -> f64 { - 5f64 - } -} -impl TriAxial for Leda { - fn subplanetary_radius(&self) -> f64 { - 5f64 - } - fn along_orbit_radius(&self) -> f64 { - 5f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Leda { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Thebe; -impl Satellite for Thebe {} -impl Body for Thebe { - fn id(&self) -> NaifId { - NaifId(514i32) - } - fn name(&self) -> &'static str { - "Thebe" - } -} -impl Display for Thebe { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Thebe { - fn polar_radius(&self) -> f64 { - 42f64 - } - fn mean_radius(&self) -> f64 { - 49.666666666666664f64 - } -} -impl TriAxial for Thebe { - fn subplanetary_radius(&self) -> f64 { - 58f64 - } - fn along_orbit_radius(&self) -> f64 { - 49f64 - } -} -impl PointMass for Thebe { - fn gravitational_parameter(&self) -> f64 { - 0.030148f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Thebe { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.678355059970801f64, - -0.00015707963267948965f64, - 0f64, - &[ - 0f64, - -0.03682644721708035f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0006981317007977319f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.125562834611143f64, - 0.00005235987755982989f64, - 0f64, - &[ - 0f64, - -0.0158824961931484f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.00017453292519943296f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 0.1494001839707146f64, - 9.31482937374367f64, - 0f64, - &[ - 0f64, - 0.033335788713091695f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0006981317007977319f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Adrastea; -impl Satellite for Adrastea {} -impl Body for Adrastea { - fn id(&self) -> NaifId { - NaifId(515i32) - } - fn name(&self) -> &'static str { - "Adrastea" - } -} -impl Display for Adrastea { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Adrastea { - fn polar_radius(&self) -> f64 { - 7f64 - } - fn mean_radius(&self) -> f64 { - 8.333333333333334f64 - } -} -impl TriAxial for Adrastea { - fn subplanetary_radius(&self) -> f64 { - 10f64 - } - fn along_orbit_radius(&self) -> f64 { - 8f64 - } -} -impl PointMass for Adrastea { - fn gravitational_parameter(&self) -> f64 { - 0.000139f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Adrastea { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.678355059970801f64, - -0.00015707963267948965f64, - 0f64, - &[] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.125562834611143f64, - 0.00005235987755982989f64, - 0f64, - &[] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 0.5810201079889122f64, - 21.066100687650238f64, - 0f64, - &[] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Metis; -impl Satellite for Metis {} -impl Body for Metis { - fn id(&self) -> NaifId { - NaifId(516i32) - } - fn name(&self) -> &'static str { - "Metis" - } -} -impl Display for Metis { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Metis { - fn polar_radius(&self) -> f64 { - 17f64 - } - fn mean_radius(&self) -> f64 { - 22.333333333333332f64 - } -} -impl TriAxial for Metis { - fn subplanetary_radius(&self) -> f64 { - 30f64 - } - fn along_orbit_radius(&self) -> f64 { - 20f64 - } -} -impl PointMass for Metis { - fn gravitational_parameter(&self) -> f64 { - 0.002501f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Metis { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.678355059970801f64, - -0.00015707963267948965f64, - 0f64, - &[] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.125562834611143f64, - 0.00005235987755982989f64, - 0f64, - &[] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 6.040410008227175f64, - 21.3149160457997f64, - 0f64, - &[] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Callirrhoe; -impl Body for Callirrhoe { - fn id(&self) -> NaifId { - NaifId(517i32) - } - fn name(&self) -> &'static str { - "Callirrhoe" - } -} -impl Display for Callirrhoe { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Callirrhoe { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Themisto; -impl Body for Themisto { - fn id(&self) -> NaifId { - NaifId(518i32) - } - fn name(&self) -> &'static str { - "Themisto" - } -} -impl Display for Themisto { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Themisto { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Magaclite; -impl Body for Magaclite { - fn id(&self) -> NaifId { - NaifId(519i32) - } - fn name(&self) -> &'static str { - "Magaclite" - } -} -impl Display for Magaclite { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Magaclite { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Taygete; -impl Body for Taygete { - fn id(&self) -> NaifId { - NaifId(520i32) - } - fn name(&self) -> &'static str { - "Taygete" - } -} -impl Display for Taygete { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Taygete { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Chaldene; -impl Body for Chaldene { - fn id(&self) -> NaifId { - NaifId(521i32) - } - fn name(&self) -> &'static str { - "Chaldene" - } -} -impl Display for Chaldene { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Chaldene { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Harpalyke; -impl Body for Harpalyke { - fn id(&self) -> NaifId { - NaifId(522i32) - } - fn name(&self) -> &'static str { - "Harpalyke" - } -} -impl Display for Harpalyke { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Harpalyke { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Kalyke; -impl Body for Kalyke { - fn id(&self) -> NaifId { - NaifId(523i32) - } - fn name(&self) -> &'static str { - "Kalyke" - } -} -impl Display for Kalyke { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Kalyke { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Iocaste; -impl Body for Iocaste { - fn id(&self) -> NaifId { - NaifId(524i32) - } - fn name(&self) -> &'static str { - "Iocaste" - } -} -impl Display for Iocaste { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Iocaste { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Erinome; -impl Body for Erinome { - fn id(&self) -> NaifId { - NaifId(525i32) - } - fn name(&self) -> &'static str { - "Erinome" - } -} -impl Display for Erinome { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Erinome { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Isonoe; -impl Body for Isonoe { - fn id(&self) -> NaifId { - NaifId(526i32) - } - fn name(&self) -> &'static str { - "Isonoe" - } -} -impl Display for Isonoe { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Isonoe { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Praxidike; -impl Body for Praxidike { - fn id(&self) -> NaifId { - NaifId(527i32) - } - fn name(&self) -> &'static str { - "Praxidike" - } -} -impl Display for Praxidike { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Praxidike { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Autonoe; -impl Body for Autonoe { - fn id(&self) -> NaifId { - NaifId(528i32) - } - fn name(&self) -> &'static str { - "Autonoe" - } -} -impl Display for Autonoe { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Autonoe { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Thyone; -impl Body for Thyone { - fn id(&self) -> NaifId { - NaifId(529i32) - } - fn name(&self) -> &'static str { - "Thyone" - } -} -impl Display for Thyone { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Thyone { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Hermippe; -impl Body for Hermippe { - fn id(&self) -> NaifId { - NaifId(530i32) - } - fn name(&self) -> &'static str { - "Hermippe" - } -} -impl Display for Hermippe { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Hermippe { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Aitne; -impl Body for Aitne { - fn id(&self) -> NaifId { - NaifId(531i32) - } - fn name(&self) -> &'static str { - "Aitne" - } -} -impl Display for Aitne { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Aitne { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Eurydome; -impl Body for Eurydome { - fn id(&self) -> NaifId { - NaifId(532i32) - } - fn name(&self) -> &'static str { - "Eurydome" - } -} -impl Display for Eurydome { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Eurydome { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Euanthe; -impl Body for Euanthe { - fn id(&self) -> NaifId { - NaifId(533i32) - } - fn name(&self) -> &'static str { - "Euanthe" - } -} -impl Display for Euanthe { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Euanthe { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Euporie; -impl Body for Euporie { - fn id(&self) -> NaifId { - NaifId(534i32) - } - fn name(&self) -> &'static str { - "Euporie" - } -} -impl Display for Euporie { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Euporie { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Orthosie; -impl Body for Orthosie { - fn id(&self) -> NaifId { - NaifId(535i32) - } - fn name(&self) -> &'static str { - "Orthosie" - } -} -impl Display for Orthosie { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Orthosie { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Sponde; -impl Body for Sponde { - fn id(&self) -> NaifId { - NaifId(536i32) - } - fn name(&self) -> &'static str { - "Sponde" - } -} -impl Display for Sponde { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Sponde { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Kale; -impl Body for Kale { - fn id(&self) -> NaifId { - NaifId(537i32) - } - fn name(&self) -> &'static str { - "Kale" - } -} -impl Display for Kale { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Kale { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Pasithee; -impl Body for Pasithee { - fn id(&self) -> NaifId { - NaifId(538i32) - } - fn name(&self) -> &'static str { - "Pasithee" - } -} -impl Display for Pasithee { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Pasithee { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Hegemone; -impl Body for Hegemone { - fn id(&self) -> NaifId { - NaifId(539i32) - } - fn name(&self) -> &'static str { - "Hegemone" - } -} -impl Display for Hegemone { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Hegemone { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Mneme; -impl Body for Mneme { - fn id(&self) -> NaifId { - NaifId(540i32) - } - fn name(&self) -> &'static str { - "Mneme" - } -} -impl Display for Mneme { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Mneme { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Aoede; -impl Body for Aoede { - fn id(&self) -> NaifId { - NaifId(541i32) - } - fn name(&self) -> &'static str { - "Aoede" - } -} -impl Display for Aoede { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Aoede { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Thelxinoe; -impl Body for Thelxinoe { - fn id(&self) -> NaifId { - NaifId(542i32) - } - fn name(&self) -> &'static str { - "Thelxinoe" - } -} -impl Display for Thelxinoe { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Thelxinoe { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Arche; -impl Body for Arche { - fn id(&self) -> NaifId { - NaifId(543i32) - } - fn name(&self) -> &'static str { - "Arche" - } -} -impl Display for Arche { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Arche { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Kallichore; -impl Body for Kallichore { - fn id(&self) -> NaifId { - NaifId(544i32) - } - fn name(&self) -> &'static str { - "Kallichore" - } -} -impl Display for Kallichore { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Kallichore { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Helike; -impl Body for Helike { - fn id(&self) -> NaifId { - NaifId(545i32) - } - fn name(&self) -> &'static str { - "Helike" - } -} -impl Display for Helike { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Helike { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Carpo; -impl Body for Carpo { - fn id(&self) -> NaifId { - NaifId(546i32) - } - fn name(&self) -> &'static str { - "Carpo" - } -} -impl Display for Carpo { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Carpo { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Eukelade; -impl Body for Eukelade { - fn id(&self) -> NaifId { - NaifId(547i32) - } - fn name(&self) -> &'static str { - "Eukelade" - } -} -impl Display for Eukelade { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Eukelade { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Cyllene; -impl Body for Cyllene { - fn id(&self) -> NaifId { - NaifId(548i32) - } - fn name(&self) -> &'static str { - "Cyllene" - } -} -impl Display for Cyllene { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Cyllene { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Kore; -impl Body for Kore { - fn id(&self) -> NaifId { - NaifId(549i32) - } - fn name(&self) -> &'static str { - "Kore" - } -} -impl Display for Kore { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Kore { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Herse; -impl Body for Herse { - fn id(&self) -> NaifId { - NaifId(550i32) - } - fn name(&self) -> &'static str { - "Herse" - } -} -impl Display for Herse { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Herse { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Dia; -impl Body for Dia { - fn id(&self) -> NaifId { - NaifId(553i32) - } - fn name(&self) -> &'static str { - "Dia" - } -} -impl Display for Dia { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Dia { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ] 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 Mimas; -impl Satellite for Mimas {} -impl Body for Mimas { - fn id(&self) -> NaifId { - NaifId(601i32) - } - fn name(&self) -> &'static str { - "Mimas" - } -} -impl Display for Mimas { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Mimas { - fn polar_radius(&self) -> f64 { - 190.6f64 - } - fn mean_radius(&self) -> f64 { - 198.36666666666667f64 - } -} -impl TriAxial for Mimas { - fn subplanetary_radius(&self) -> f64 { - 207.8f64 - } - fn along_orbit_radius(&self) -> f64 { - 196.7f64 - } -} -impl PointMass for Mimas { - fn gravitational_parameter(&self) -> f64 { - 2.503488768152587f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Mimas { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7096508738608943f64, - -0.0006283185307179586f64, - 0f64, - &[ - 0f64, - 0f64, - 0.2366666465704311f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.457698991265664f64, - -0.00006981317007977319f64, - 0f64, - &[ - 0f64, - 0f64, - -0.026703537555513242f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 5.819974923700291f64, - 6.667062709440567f64, - 0f64, - &[ - 0f64, - 0f64, - -0.23527038316883564f64, - 0f64, - -0.7827801695194568f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Enceladus; -impl Satellite for Enceladus {} -impl Body for Enceladus { - fn id(&self) -> NaifId { - NaifId(602i32) - } - fn name(&self) -> &'static str { - "Enceladus" - } -} -impl Display for Enceladus { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Enceladus { - fn polar_radius(&self) -> f64 { - 248.3f64 - } - fn mean_radius(&self) -> f64 { - 252.1f64 - } -} -impl TriAxial for Enceladus { - fn subplanetary_radius(&self) -> f64 { - 256.6f64 - } - fn along_orbit_radius(&self) -> f64 { - 251.4f64 - } -} -impl PointMass for Enceladus { - fn gravitational_parameter(&self) -> f64 { - 7.210366688598896f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Enceladus { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7096508738608943f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.457698991265664f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 0.11030480872604163f64, - 4.585536698039173f64, - 0f64, - &[] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Tethys; -impl Satellite for Tethys {} -impl Body for Tethys { - fn id(&self) -> NaifId { - NaifId(603i32) - } - fn name(&self) -> &'static str { - "Tethys" - } -} -impl Display for Tethys { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Tethys { - fn polar_radius(&self) -> f64 { - 526.3f64 - } - fn mean_radius(&self) -> f64 { - 530.9999999999999f64 - } -} -impl TriAxial for Tethys { - fn subplanetary_radius(&self) -> f64 { - 538.4f64 - } - fn along_orbit_radius(&self) -> f64 { - 528.3f64 - } -} -impl PointMass for Tethys { - fn gravitational_parameter(&self) -> f64 { - 41.21352885489587f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Tethys { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7096508738608943f64, - -0.0006283185307179586f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0.16859880574265224f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.457698991265664f64, - -0.00006981317007977319f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - -0.019024088846738195f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 0.1562069680534925f64, - 3.328306379991881f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - -0.16755160819145562f64, - 0.03892084231947355f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Dione; -impl Satellite for Dione {} -impl Body for Dione { - fn id(&self) -> NaifId { - NaifId(604i32) - } - fn name(&self) -> &'static str { - "Dione" - } -} -impl Display for Dione { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Dione { - fn polar_radius(&self) -> f64 { - 559.6f64 - } - fn mean_radius(&self) -> f64 { - 561.4333333333333f64 - } -} -impl TriAxial for Dione { - fn subplanetary_radius(&self) -> f64 { - 563.4f64 - } - fn along_orbit_radius(&self) -> f64 { - 561.3f64 - } -} -impl PointMass for Dione { - fn gravitational_parameter(&self) -> f64 { - 73.11607172482067f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Dione { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7096508738608943f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.457698991265664f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 6.241297405131723f64, - 2.295717637805533f64, - 0f64, - &[] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Rhea; -impl Satellite for Rhea {} -impl Body for Rhea { - fn id(&self) -> NaifId { - NaifId(605i32) - } - fn name(&self) -> &'static str { - "Rhea" - } -} -impl Display for Rhea { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Rhea { - fn polar_radius(&self) -> f64 { - 762.4f64 - } - fn mean_radius(&self) -> f64 { - 763.5f64 - } -} -impl TriAxial for Rhea { - fn subplanetary_radius(&self) -> f64 { - 765f64 - } - fn along_orbit_radius(&self) -> f64 { - 763.1f64 - } -} -impl PointMass for Rhea { - fn gravitational_parameter(&self) -> f64 { - 153.9417519146563f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Rhea { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7047639519553103f64, - -0.0006283185307179586f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.054105206811824215f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.4582225900412622f64, - -0.00006981317007977319f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.006108652381980153f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 4.104316268989865f64, - 1.3908537151816638f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.05375614096142535f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Titan; -impl Satellite for Titan {} -impl Body for Titan { - fn id(&self) -> NaifId { - NaifId(606i32) - } - fn name(&self) -> &'static str { - "Titan" - } -} -impl Display for Titan { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Titan { - fn polar_radius(&self) -> f64 { - 2574.47f64 - } - fn mean_radius(&self) -> f64 { - 2574.7999999999997f64 - } -} -impl TriAxial for Titan { - fn subplanetary_radius(&self) -> f64 { - 2575.15f64 - } - fn along_orbit_radius(&self) -> f64 { - 2574.78f64 - } -} -impl PointMass for Titan { - fn gravitational_parameter(&self) -> f64 { - 8978.137095521046f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Titan { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 0.6891031125771652f64, - 0f64, - 0f64, - &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.456091543024577f64, - 0f64, - 0f64, - &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 3.2565313114798795f64, - 0.39404258030637335f64, - 0f64, - &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Hyperion; -impl Satellite for Hyperion {} -impl Body for Hyperion { - fn id(&self) -> NaifId { - NaifId(607i32) - } - fn name(&self) -> &'static str { - "Hyperion" - } -} -impl Display for Hyperion { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Hyperion { - fn polar_radius(&self) -> f64 { - 102.7f64 - } - fn mean_radius(&self) -> f64 { - 138.6f64 - } -} -impl TriAxial for Hyperion { - fn subplanetary_radius(&self) -> f64 { - 180.1f64 - } - fn along_orbit_radius(&self) -> f64 { - 133f64 - } -} -impl PointMass for Hyperion { - fn gravitational_parameter(&self) -> f64 { - 0.3704913747932265f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Hyperion { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Iapetus; -impl Satellite for Iapetus {} -impl Body for Iapetus { - fn id(&self) -> NaifId { - NaifId(608i32) - } - fn name(&self) -> &'static str { - "Iapetus" - } -} -impl Display for Iapetus { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Iapetus { - fn polar_radius(&self) -> f64 { - 712.1f64 - } - fn mean_radius(&self) -> f64 { - 734.5f64 - } -} -impl TriAxial for Iapetus { - fn subplanetary_radius(&self) -> f64 { - 745.7f64 - } - fn along_orbit_radius(&self) -> f64 { - 745.7f64 - } -} -impl PointMass for Iapetus { - fn gravitational_parameter(&self) -> f64 { - 120.5151060137642f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Iapetus { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 5.552939548145159f64, - -0.06892305216125608f64, - 0f64, - &[] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.3095205377713455f64, - -0.019949113350295186f64, - 0f64, - &[] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 6.199409503083858f64, - 0.07920229445458282f64, - 0f64, - &[] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Phoebe; -impl Satellite for Phoebe {} -impl Body for Phoebe { - fn id(&self) -> NaifId { - NaifId(609i32) - } - fn name(&self) -> &'static str { - "Phoebe" - } -} -impl Display for Phoebe { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Phoebe { - fn polar_radius(&self) -> f64 { - 101.8f64 - } - fn mean_radius(&self) -> f64 { - 106.56666666666666f64 - } -} -impl TriAxial for Phoebe { - fn subplanetary_radius(&self) -> f64 { - 109.4f64 - } - fn along_orbit_radius(&self) -> f64 { - 108.5f64 - } -} -impl PointMass for Phoebe { - fn gravitational_parameter(&self) -> f64 { - 0.5547860052791678f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Phoebe { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - (6.229080100367762f64, 0f64, 0f64, &[] as &[f64]) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - (1.3578661580515883f64, 0f64, 0f64, &[] as &[f64]) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 3.116808978211474f64, - 16.26016798998745f64, - 0f64, - &[] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Janus; -impl Satellite for Janus {} -impl Body for Janus { - fn id(&self) -> NaifId { - NaifId(610i32) - } - fn name(&self) -> &'static str { - "Janus" - } -} -impl Display for Janus { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Janus { - fn polar_radius(&self) -> f64 { - 76.3f64 - } - fn mean_radius(&self) -> f64 { - 90.33333333333333f64 - } -} -impl TriAxial for Janus { - fn subplanetary_radius(&self) -> f64 { - 101.7f64 - } - fn along_orbit_radius(&self) -> f64 { - 93f64 - } -} -impl PointMass for Janus { - fn gravitational_parameter(&self) -> f64 { - 0.1265765099012197f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Janus { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7082546104592989f64, - -0.0006283185307179586f64, - 0f64, - &[ - 0f64, - -0.028326693759867967f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0004014257279586958f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.457698991265664f64, - -0.00006981317007977319f64, - 0f64, - &[ - 0f64, - -0.003193952531149623f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.000017453292519943296f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 1.0267771989482641f64, - 9.044924285944507f64, - 0f64, - &[ - 0f64, - 0.028152160834668535f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0004014257279586958f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Epimetheus; -impl Satellite for Epimetheus {} -impl Body for Epimetheus { - fn id(&self) -> NaifId { - NaifId(611i32) - } - fn name(&self) -> &'static str { - "Epimetheus" - } -} -impl Display for Epimetheus { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Epimetheus { - fn polar_radius(&self) -> f64 { - 53f64 - } - fn mean_radius(&self) -> f64 { - 58.4f64 - } -} -impl TriAxial for Epimetheus { - fn subplanetary_radius(&self) -> f64 { - 64.9f64 - } - fn along_orbit_radius(&self) -> f64 { - 57.3f64 - } -} -impl PointMass for Epimetheus { - fn gravitational_parameter(&self) -> f64 { - 0.03512333288208074f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Epimetheus { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7082546104592989f64, - -0.0006283185307179586f64, - 0f64, - &[ - -0.05503023131538121f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0015009831567151233f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.457698991265664f64, - -0.00006981317007977319f64, - 0f64, - &[ - -0.006213372137099813f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.00008726646259971648f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 5.128999072835736f64, - 9.049370273103856f64, - 0f64, - &[ - 0.05468116546498235f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0015009831567151233f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Helene; -impl Satellite for Helene {} -impl Body for Helene { - fn id(&self) -> NaifId { - NaifId(612i32) - } - fn name(&self) -> &'static str { - "Helene" - } -} -impl Display for Helene { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Helene { - fn polar_radius(&self) -> f64 { - 13.3f64 - } - fn mean_radius(&self) -> f64 { - 18.46666666666667f64 - } -} -impl TriAxial for Helene { - fn subplanetary_radius(&self) -> f64 { - 22.5f64 - } - fn along_orbit_radius(&self) -> f64 { - 19.6f64 - } -} -impl PointMass for Helene { - fn gravitational_parameter(&self) -> f64 { - 0.0004757419551776972f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Helene { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7129669994396837f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.4545573986120743f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 4.278151062488501f64, - 2.297157080652823f64, - 0f64, - &[] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Telesto; -impl Body for Telesto { - fn id(&self) -> NaifId { - NaifId(613i32) - } - fn name(&self) -> &'static str { - "Telesto" - } -} -impl Display for Telesto { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Telesto { - fn polar_radius(&self) -> f64 { - 9.8f64 - } - fn mean_radius(&self) -> f64 { - 12.633333333333335f64 - } -} -impl TriAxial for Telesto { - fn subplanetary_radius(&self) -> f64 { - 16.3f64 - } - fn along_orbit_radius(&self) -> f64 { - 11.8f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Telesto { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 0.8815658051823358f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.4671237692264334f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 0.9927432785343747f64, - 3.328306811088206f64, - 0f64, - &[] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Calypso; -impl Body for Calypso { - fn id(&self) -> NaifId { - NaifId(614i32) - } - fn name(&self) -> &'static str { - "Calypso" - } -} -impl Display for Calypso { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Calypso { - fn polar_radius(&self) -> f64 { - 6.3f64 - } - fn mean_radius(&self) -> f64 { - 10.3f64 - } -} -impl TriAxial for Calypso { - fn subplanetary_radius(&self) -> f64 { - 15.3f64 - } - fn along_orbit_radius(&self) -> f64 { - 9.3f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Calypso { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 0.6354743806511354f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.4842279958959779f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 2.679254934736495f64, - 3.327893239613983f64, - 0f64, - &[] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Atlas; -impl Satellite for Atlas {} -impl Body for Atlas { - fn id(&self) -> NaifId { - NaifId(615i32) - } - fn name(&self) -> &'static str { - "Atlas" - } -} -impl Display for Atlas { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Atlas { - fn polar_radius(&self) -> f64 { - 9.4f64 - } - fn mean_radius(&self) -> f64 { - 15.899999999999999f64 - } -} -impl TriAxial for Atlas { - fn subplanetary_radius(&self) -> f64 { - 20.5f64 - } - fn along_orbit_radius(&self) -> f64 { - 17.8f64 - } -} -impl PointMass for Atlas { - fn gravitational_parameter(&self) -> f64 { - 0.0003718871247516475f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Atlas { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7082546104592989f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.4578735241908636f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 2.4064599726497815f64, - 10.442409634437194f64, - 0f64, - &[] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Prometheus; -impl Satellite for Prometheus {} -impl Body for Prometheus { - fn id(&self) -> NaifId { - NaifId(616i32) - } - fn name(&self) -> &'static str { - "Prometheus" - } -} -impl Display for Prometheus { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Prometheus { - fn polar_radius(&self) -> f64 { - 28.2f64 - } - fn mean_radius(&self) -> f64 { - 46f64 - } -} -impl TriAxial for Prometheus { - fn subplanetary_radius(&self) -> f64 { - 68.2f64 - } - fn along_orbit_radius(&self) -> f64 { - 41.6f64 - } -} -impl PointMass for Prometheus { - fn gravitational_parameter(&self) -> f64 { - 0.0107520800100761f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Prometheus { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7082546104592989f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.4578735241908636f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 5.1686180468560075f64, - 10.250126710744977f64, - 0f64, - &[] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Pandora; -impl Satellite for Pandora {} -impl Body for Pandora { - fn id(&self) -> NaifId { - NaifId(617i32) - } - fn name(&self) -> &'static str { - "Pandora" - } -} -impl Display for Pandora { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Pandora { - fn polar_radius(&self) -> f64 { - 31.5f64 - } - fn mean_radius(&self) -> f64 { - 41.5f64 - } -} -impl TriAxial for Pandora { - fn subplanetary_radius(&self) -> f64 { - 52.2f64 - } - fn along_orbit_radius(&self) -> f64 { - 40.8f64 - } -} -impl PointMass for Pandora { - fn gravitational_parameter(&self) -> f64 { - 0.009290325122028795f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Pandora { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7082546104592989f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.4578735241908636f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 2.8434904173491615f64, - 9.997055714535051f64, - 0f64, - &[] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Pan; -impl Body for Pan { - fn id(&self) -> NaifId { - NaifId(618i32) - } - fn name(&self) -> &'static str { - "Pan" - } -} -impl Display for Pan { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Pan { - fn polar_radius(&self) -> f64 { - 10.4f64 - } - fn mean_radius(&self) -> f64 { - 14.333333333333334f64 - } -} -impl TriAxial for Pan { - fn subplanetary_radius(&self) -> f64 { - 17.2f64 - } - fn along_orbit_radius(&self) -> f64 { - 15.4f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Pan { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7086036763096978f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.457349925415265f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 0.8517206749732328f64, - 10.92652906235538f64, - 0f64, - &[] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Ymir; -impl Body for Ymir { - fn id(&self) -> NaifId { - NaifId(619i32) - } - fn name(&self) -> &'static str { - "Ymir" - } -} -impl Display for Ymir { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Ymir { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Paaliaq; -impl Body for Paaliaq { - fn id(&self) -> NaifId { - NaifId(620i32) - } - fn name(&self) -> &'static str { - "Paaliaq" - } -} -impl Display for Paaliaq { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Paaliaq { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Tarvos; -impl Body for Tarvos { - fn id(&self) -> NaifId { - NaifId(621i32) - } - fn name(&self) -> &'static str { - "Tarvos" - } -} -impl Display for Tarvos { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Tarvos { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Ijiraq; -impl Body for Ijiraq { - fn id(&self) -> NaifId { - NaifId(622i32) - } - fn name(&self) -> &'static str { - "Ijiraq" - } -} -impl Display for Ijiraq { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Ijiraq { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Suttungr; -impl Body for Suttungr { - fn id(&self) -> NaifId { - NaifId(623i32) - } - fn name(&self) -> &'static str { - "Suttungr" - } -} -impl Display for Suttungr { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Suttungr { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Kiviuq; -impl Body for Kiviuq { - fn id(&self) -> NaifId { - NaifId(624i32) - } - fn name(&self) -> &'static str { - "Kiviuq" - } -} -impl Display for Kiviuq { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Kiviuq { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Mundilfari; -impl Body for Mundilfari { - fn id(&self) -> NaifId { - NaifId(625i32) - } - fn name(&self) -> &'static str { - "Mundilfari" - } -} -impl Display for Mundilfari { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Mundilfari { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Albiorix; -impl Body for Albiorix { - fn id(&self) -> NaifId { - NaifId(626i32) - } - fn name(&self) -> &'static str { - "Albiorix" - } -} -impl Display for Albiorix { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Albiorix { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Skathi; -impl Body for Skathi { - fn id(&self) -> NaifId { - NaifId(627i32) - } - fn name(&self) -> &'static str { - "Skathi" - } -} -impl Display for Skathi { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Skathi { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Erriapus; -impl Body for Erriapus { - fn id(&self) -> NaifId { - NaifId(628i32) - } - fn name(&self) -> &'static str { - "Erriapus" - } -} -impl Display for Erriapus { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Erriapus { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Siarnaq; -impl Body for Siarnaq { - fn id(&self) -> NaifId { - NaifId(629i32) - } - fn name(&self) -> &'static str { - "Siarnaq" - } -} -impl Display for Siarnaq { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Siarnaq { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Thrymr; -impl Body for Thrymr { - fn id(&self) -> NaifId { - NaifId(630i32) - } - fn name(&self) -> &'static str { - "Thrymr" - } -} -impl Display for Thrymr { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Thrymr { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Narvi; -impl Body for Narvi { - fn id(&self) -> NaifId { - NaifId(631i32) - } - fn name(&self) -> &'static str { - "Narvi" - } -} -impl Display for Narvi { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Narvi { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Methone; -impl Body for Methone { - fn id(&self) -> NaifId { - NaifId(632i32) - } - fn name(&self) -> &'static str { - "Methone" - } -} -impl Display for Methone { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Methone { - fn polar_radius(&self) -> f64 { - 1.21f64 - } - fn mean_radius(&self) -> f64 { - 1.4799999999999998f64 - } -} -impl TriAxial for Methone { - fn subplanetary_radius(&self) -> f64 { - 1.94f64 - } - fn along_orbit_radius(&self) -> f64 { - 1.29f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Methone { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Pallene; -impl Body for Pallene { - fn id(&self) -> NaifId { - NaifId(633i32) - } - fn name(&self) -> &'static str { - "Pallene" - } -} -impl Display for Pallene { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Pallene { - fn polar_radius(&self) -> f64 { - 1.8f64 - } - fn mean_radius(&self) -> f64 { - 2.2533333333333334f64 - } -} -impl TriAxial for Pallene { - fn subplanetary_radius(&self) -> f64 { - 2.88f64 - } - fn along_orbit_radius(&self) -> f64 { - 2.08f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Pallene { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Polydeuces; -impl Body for Polydeuces { - fn id(&self) -> NaifId { - NaifId(634i32) - } - fn name(&self) -> &'static str { - "Polydeuces" - } -} -impl Display for Polydeuces { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Polydeuces { - fn polar_radius(&self) -> f64 { - 1f64 - } - fn mean_radius(&self) -> f64 { - 1.2333333333333334f64 - } -} -impl TriAxial for Polydeuces { - fn subplanetary_radius(&self) -> f64 { - 1.5f64 - } - fn along_orbit_radius(&self) -> f64 { - 1.2f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Polydeuces { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Daphnis; -impl Body for Daphnis { - fn id(&self) -> NaifId { - NaifId(635i32) - } - fn name(&self) -> &'static str { - "Daphnis" - } -} -impl Display for Daphnis { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Daphnis { - fn polar_radius(&self) -> f64 { - 2.8f64 - } - fn mean_radius(&self) -> f64 { - 3.9666666666666663f64 - } -} -impl TriAxial for Daphnis { - fn subplanetary_radius(&self) -> f64 { - 4.6f64 - } - fn along_orbit_radius(&self) -> f64 { - 4.5f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Daphnis { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Aegir; -impl Body for Aegir { - fn id(&self) -> NaifId { - NaifId(636i32) - } - fn name(&self) -> &'static str { - "Aegir" - } -} -impl Display for Aegir { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Aegir { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Bebhionn; -impl Body for Bebhionn { - fn id(&self) -> NaifId { - NaifId(637i32) - } - fn name(&self) -> &'static str { - "Bebhionn" - } -} -impl Display for Bebhionn { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Bebhionn { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Bergelmir; -impl Body for Bergelmir { - fn id(&self) -> NaifId { - NaifId(638i32) - } - fn name(&self) -> &'static str { - "Bergelmir" - } -} -impl Display for Bergelmir { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Bergelmir { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Bestla; -impl Body for Bestla { - fn id(&self) -> NaifId { - NaifId(639i32) - } - fn name(&self) -> &'static str { - "Bestla" - } -} -impl Display for Bestla { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Bestla { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Farbauti; -impl Body for Farbauti { - fn id(&self) -> NaifId { - NaifId(640i32) - } - fn name(&self) -> &'static str { - "Farbauti" - } -} -impl Display for Farbauti { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Farbauti { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Fenrir; -impl Body for Fenrir { - fn id(&self) -> NaifId { - NaifId(641i32) - } - fn name(&self) -> &'static str { - "Fenrir" - } -} -impl Display for Fenrir { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Fenrir { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Fornjot; -impl Body for Fornjot { - fn id(&self) -> NaifId { - NaifId(642i32) - } - fn name(&self) -> &'static str { - "Fornjot" - } -} -impl Display for Fornjot { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Fornjot { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Hati; -impl Body for Hati { - fn id(&self) -> NaifId { - NaifId(643i32) - } - fn name(&self) -> &'static str { - "Hati" - } -} -impl Display for Hati { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Hati { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Hyrrokkin; -impl Body for Hyrrokkin { - fn id(&self) -> NaifId { - NaifId(644i32) - } - fn name(&self) -> &'static str { - "Hyrrokkin" - } -} -impl Display for Hyrrokkin { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Hyrrokkin { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Kari; -impl Body for Kari { - fn id(&self) -> NaifId { - NaifId(645i32) - } - fn name(&self) -> &'static str { - "Kari" - } -} -impl Display for Kari { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Kari { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Loge; -impl Body for Loge { - fn id(&self) -> NaifId { - NaifId(646i32) - } - fn name(&self) -> &'static str { - "Loge" - } -} -impl Display for Loge { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Loge { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Skoll; -impl Body for Skoll { - fn id(&self) -> NaifId { - NaifId(647i32) - } - fn name(&self) -> &'static str { - "Skoll" - } -} -impl Display for Skoll { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Skoll { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Surtur; -impl Body for Surtur { - fn id(&self) -> NaifId { - NaifId(648i32) - } - fn name(&self) -> &'static str { - "Surtur" - } -} -impl Display for Surtur { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Surtur { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Anthe; -impl Body for Anthe { - fn id(&self) -> NaifId { - NaifId(649i32) - } - fn name(&self) -> &'static str { - "Anthe" - } -} -impl Display for Anthe { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Anthe { - fn polar_radius(&self) -> f64 { - 0.5f64 - } - fn mean_radius(&self) -> f64 { - 0.5f64 - } -} -impl TriAxial for Anthe { - fn subplanetary_radius(&self) -> f64 { - 0.5f64 - } - fn along_orbit_radius(&self) -> f64 { - 0.5f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Anthe { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Jarnsaxa; -impl Body for Jarnsaxa { - fn id(&self) -> NaifId { - NaifId(650i32) - } - fn name(&self) -> &'static str { - "Jarnsaxa" - } -} -impl Display for Jarnsaxa { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Jarnsaxa { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Greip; -impl Body for Greip { - fn id(&self) -> NaifId { - NaifId(651i32) - } - fn name(&self) -> &'static str { - "Greip" - } -} -impl Display for Greip { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Greip { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Tarqeq; -impl Body for Tarqeq { - fn id(&self) -> NaifId { - NaifId(652i32) - } - fn name(&self) -> &'static str { - "Tarqeq" - } -} -impl Display for Tarqeq { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Tarqeq { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Aegaeon; -impl Body for Aegaeon { - fn id(&self) -> NaifId { - NaifId(653i32) - } - fn name(&self) -> &'static str { - "Aegaeon" - } -} -impl Display for Aegaeon { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Aegaeon { - fn polar_radius(&self) -> f64 { - 0.2f64 - } - fn mean_radius(&self) -> f64 { - 0.3833333333333333f64 - } -} -impl TriAxial for Aegaeon { - fn subplanetary_radius(&self) -> f64 { - 0.7f64 - } - fn along_orbit_radius(&self) -> f64 { - 0.25f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Aegaeon { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64, - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64, - ] 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 Ariel; -impl Satellite for Ariel {} -impl Body for Ariel { - fn id(&self) -> NaifId { - NaifId(701i32) - } - fn name(&self) -> &'static str { - "Ariel" - } -} -impl Display for Ariel { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Ariel { - fn polar_radius(&self) -> f64 { - 577.7f64 - } - fn mean_radius(&self) -> f64 { - 578.9f64 - } -} -impl TriAxial for Ariel { - fn subplanetary_radius(&self) -> f64 { - 581.1f64 - } - fn along_orbit_radius(&self) -> f64 { - 577.9f64 - } -} -impl PointMass for Ariel { - fn gravitational_parameter(&self) -> f64 { - 83.46344431770477f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Ariel { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.493001093409003f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.005061454830783556f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - -0.26354471705114374f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.004886921905584123f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 2.7265533574655416f64, - -2.492952697630833f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0008726646259971648f64, - 0.0013962634015954637f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Umbriel; -impl Satellite for Umbriel {} -impl Body for Umbriel { - fn id(&self) -> NaifId { - NaifId(702i32) - } - fn name(&self) -> &'static str { - "Umbriel" - } -} -impl Display for Umbriel { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Umbriel { - fn polar_radius(&self) -> f64 { - 584.7f64 - } - fn mean_radius(&self) -> f64 { - 584.7f64 - } -} -impl TriAxial for Umbriel { - fn subplanetary_radius(&self) -> f64 { - 584.7f64 - } - fn along_orbit_radius(&self) -> f64 { - 584.7f64 - } -} -impl PointMass for Umbriel { - fn gravitational_parameter(&self) -> f64 { - 85.09338094489388f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Umbriel { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.493001093409003f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.003665191429188092f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - -0.26354471705114374f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.003490658503988659f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 1.885828256779873f64, - -1.5161481881953498f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0015707963267948964f64, - 0f64, - 0.0010471975511965976f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Titania; -impl Satellite for Titania {} -impl Body for Titania { - fn id(&self) -> NaifId { - NaifId(703i32) - } - fn name(&self) -> &'static str { - "Titania" - } -} -impl Display for Titania { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Titania { - fn polar_radius(&self) -> f64 { - 788.9f64 - } - fn mean_radius(&self) -> f64 { - 788.9f64 - } -} -impl TriAxial for Titania { - fn subplanetary_radius(&self) -> f64 { - 788.9f64 - } - fn along_orbit_radius(&self) -> f64 { - 788.9f64 - } -} -impl PointMass for Titania { - fn gravitational_parameter(&self) -> f64 { - 226.9437003741248f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Titania { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.493001093409003f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.005061454830783556f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - -0.26354471705114374f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.004886921905584123f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 1.3568189605003917f64, - -0.7217186318332268f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0013962634015954637f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Oberon; -impl Satellite for Oberon {} -impl Body for Oberon { - fn id(&self) -> NaifId { - NaifId(704i32) - } - fn name(&self) -> &'static str { - "Oberon" - } -} -impl Display for Oberon { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Oberon { - fn polar_radius(&self) -> f64 { - 761.4f64 - } - fn mean_radius(&self) -> f64 { - 761.4f64 - } -} -impl TriAxial for Oberon { - fn subplanetary_radius(&self) -> f64 { - 761.4f64 - } - fn along_orbit_radius(&self) -> f64 { - 761.4f64 - } -} -impl PointMass for Oberon { - fn gravitational_parameter(&self) -> f64 { - 205.3234302535623f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Oberon { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.493001093409003f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0027925268031909274f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - -0.26354471705114374f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0027925268031909274f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 0.1181587903600161f64, - -0.4666921966546346f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0006981317007977319f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Miranda; -impl Satellite for Miranda {} -impl Body for Miranda { - fn id(&self) -> NaifId { - NaifId(705i32) - } - fn name(&self) -> &'static str { - "Miranda" - } -} -impl Display for Miranda { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Miranda { - fn polar_radius(&self) -> f64 { - 232.9f64 - } - fn mean_radius(&self) -> f64 { - 235.83333333333334f64 - } -} -impl TriAxial for Miranda { - fn subplanetary_radius(&self) -> f64 { - 240.4f64 - } - fn along_orbit_radius(&self) -> f64 { - 234.2f64 - } -} -impl PointMass for Miranda { - fn gravitational_parameter(&self) -> f64 { - 4.3195168992321f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Miranda { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.493001093409003f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.07696902001294993f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0006981317007977319f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - -0.2631956512007449f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.07417649320975901f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.00034906585039886593f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 0.5358160803622591f64, - -4.445191100713563f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.02007128639793479f64, - -0.022165681500327987f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0015707963267948964f64, - 0.002617993877991494f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Cordelia; -impl Body for Cordelia { - fn id(&self) -> NaifId { - NaifId(706i32) - } - fn name(&self) -> &'static str { - "Cordelia" - } -} -impl Display for Cordelia { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Cordelia { - fn polar_radius(&self) -> f64 { - 13f64 - } - fn mean_radius(&self) -> f64 { - 13f64 - } -} -impl TriAxial for Cordelia { - fn subplanetary_radius(&self) -> f64 { - 13f64 - } - fn along_orbit_radius(&self) -> f64 { - 13f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Cordelia { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - -0.002617993877991494f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0.0024434609527920616f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 2.2286109218715593f64, - -18.753921879266084f64, - 0f64, - &[ - -0.0006981317007977319f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Ophelia; -impl Body for Ophelia { - fn id(&self) -> NaifId { - NaifId(707i32) - } - fn name(&self) -> &'static str { - "Ophelia" - } -} -impl Display for Ophelia { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Ophelia { - fn polar_radius(&self) -> f64 { - 15f64 - } - fn mean_radius(&self) -> f64 { - 15f64 - } -} -impl TriAxial for Ophelia { - fn subplanetary_radius(&self) -> f64 { - 15f64 - } - fn along_orbit_radius(&self) -> f64 { - 15f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Ophelia { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - 0f64, - -0.0015707963267948964f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0f64, - 0.0015707963267948964f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 2.2750366799746087f64, - -16.692447910262292f64, - 0f64, - &[ - 0f64, - -0.0005235987755982988f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Bianca; -impl Body for Bianca { - fn id(&self) -> NaifId { - NaifId(708i32) - } - fn name(&self) -> &'static str { - "Bianca" - } -} -impl Display for Bianca { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Bianca { - fn polar_radius(&self) -> f64 { - 21f64 - } - fn mean_radius(&self) -> f64 { - 21f64 - } -} -impl TriAxial for Bianca { - fn subplanetary_radius(&self) -> f64 { - 21f64 - } - fn along_orbit_radius(&self) -> f64 { - 21f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Bianca { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - -0.0027925268031909274f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0.0027925268031909274f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 1.8406242291532198f64, - -14.458158751655587f64, - 0f64, - &[ - 0f64, - 0f64, - -0.0006981317007977319f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Cressida; -impl Body for Cressida { - fn id(&self) -> NaifId { - NaifId(709i32) - } - fn name(&self) -> &'static str { - "Cressida" - } -} -impl Display for Cressida { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Cressida { - fn polar_radius(&self) -> f64 { - 31f64 - } - fn mean_radius(&self) -> f64 { - 31f64 - } -} -impl TriAxial for Cressida { - fn subplanetary_radius(&self) -> f64 { - 31f64 - } - fn along_orbit_radius(&self) -> f64 { - 31f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Cressida { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - -0.0006981317007977319f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0.0006981317007977319f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 1.0325367854798453f64, - -13.553906388910956f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - -0.00017453292519943296f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Desdemona; -impl Body for Desdemona { - fn id(&self) -> NaifId { - NaifId(710i32) - } - fn name(&self) -> &'static str { - "Desdemona" - } -} -impl Display for Desdemona { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Desdemona { - fn polar_radius(&self) -> f64 { - 27f64 - } - fn mean_radius(&self) -> f64 { - 27f64 - } -} -impl TriAxial for Desdemona { - fn subplanetary_radius(&self) -> f64 { - 27f64 - } - fn along_orbit_radius(&self) -> f64 { - 27f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Desdemona { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - -0.0029670597283903604f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0.0027925268031909274f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 1.6594590527962085f64, - -13.265430289266899f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - -0.0006981317007977319f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Juliet; -impl Body for Juliet { - fn id(&self) -> NaifId { - NaifId(711i32) - } - fn name(&self) -> &'static str { - "Juliet" - } -} -impl Display for Juliet { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Juliet { - fn polar_radius(&self) -> f64 { - 42f64 - } - fn mean_radius(&self) -> f64 { - 42f64 - } -} -impl TriAxial for Juliet { - fn subplanetary_radius(&self) -> f64 { - 42f64 - } - fn along_orbit_radius(&self) -> f64 { - 42f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Juliet { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0010471975511965976f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0010471975511965976f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 5.2806681848340435f64, - -12.74309158902866f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.00034906585039886593f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Portia; -impl Body for Portia { - fn id(&self) -> NaifId { - NaifId(712i32) - } - fn name(&self) -> &'static str { - "Portia" - } -} -impl Display for Portia { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Portia { - fn polar_radius(&self) -> f64 { - 54f64 - } - fn mean_radius(&self) -> f64 { - 54f64 - } -} -impl TriAxial for Portia { - fn subplanetary_radius(&self) -> f64 { - 54f64 - } - fn along_orbit_radius(&self) -> f64 { - 54f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Portia { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0015707963267948964f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0015707963267948964f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 0.4368559117741807f64, - -12.243250601727652f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.00034906585039886593f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Rosalind; -impl Body for Rosalind { - fn id(&self) -> NaifId { - NaifId(713i32) - } - fn name(&self) -> &'static str { - "Rosalind" - } -} -impl Display for Rosalind { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Rosalind { - fn polar_radius(&self) -> f64 { - 27f64 - } - fn mean_radius(&self) -> f64 { - 27f64 - } -} -impl TriAxial for Rosalind { - fn subplanetary_radius(&self) -> f64 { - 27f64 - } - fn along_orbit_radius(&self) -> f64 { - 27f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Rosalind { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.005061454830783556f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.004886921905584123f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 5.496041814530144f64, - -11.250935609538423f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0013962634015954637f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Belinda; -impl Body for Belinda { - fn id(&self) -> NaifId { - NaifId(714i32) - } - fn name(&self) -> &'static str { - "Belinda" - } -} -impl Display for Belinda { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Belinda { - fn polar_radius(&self) -> f64 { - 33f64 - } - fn mean_radius(&self) -> f64 { - 33f64 - } -} -impl TriAxial for Belinda { - fn subplanetary_radius(&self) -> f64 { - 33f64 - } - fn along_orbit_radius(&self) -> f64 { - 33f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Belinda { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0005235987755982988f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0005235987755982988f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 5.191656392982332f64, - -10.076882135239488f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.00017453292519943296f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Puck; -impl Body for Puck { - fn id(&self) -> NaifId { - NaifId(715i32) - } - fn name(&self) -> &'static str { - "Puck" - } -} -impl Display for Puck { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Puck { - fn polar_radius(&self) -> f64 { - 77f64 - } - fn mean_radius(&self) -> f64 { - 77f64 - } -} -impl TriAxial for Puck { - fn subplanetary_radius(&self) -> f64 { - 77f64 - } - fn along_orbit_radius(&self) -> f64 { - 77f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Puck { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.005759586531581287f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0054105206811824215f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 1.5924384095196262f64, - -8.247467318113788f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0015707963267948964f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Caliban; -impl Body for Caliban { - fn id(&self) -> NaifId { - NaifId(716i32) - } - fn name(&self) -> &'static str { - "Caliban" - } -} -impl Display for Caliban { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Caliban { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] 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 Sycorax; -impl Body for Sycorax { - fn id(&self) -> NaifId { - NaifId(717i32) - } - fn name(&self) -> &'static str { - "Sycorax" - } -} -impl Display for Sycorax { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Sycorax { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] 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 Prospero; -impl Body for Prospero { - fn id(&self) -> NaifId { - NaifId(718i32) - } - fn name(&self) -> &'static str { - "Prospero" - } -} -impl Display for Prospero { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Prospero { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] 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 Setebos; -impl Body for Setebos { - fn id(&self) -> NaifId { - NaifId(719i32) - } - fn name(&self) -> &'static str { - "Setebos" - } -} -impl Display for Setebos { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Setebos { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] 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 Stephano; -impl Body for Stephano { - fn id(&self) -> NaifId { - NaifId(720i32) - } - fn name(&self) -> &'static str { - "Stephano" - } -} -impl Display for Stephano { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Stephano { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] 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 Trinculo; -impl Body for Trinculo { - fn id(&self) -> NaifId { - NaifId(721i32) - } - fn name(&self) -> &'static str { - "Trinculo" - } -} -impl Display for Trinculo { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Trinculo { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] 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 Francisco; -impl Body for Francisco { - fn id(&self) -> NaifId { - NaifId(722i32) - } - fn name(&self) -> &'static str { - "Francisco" - } -} -impl Display for Francisco { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Francisco { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] 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 Margaret; -impl Body for Margaret { - fn id(&self) -> NaifId { - NaifId(723i32) - } - fn name(&self) -> &'static str { - "Margaret" - } -} -impl Display for Margaret { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Margaret { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] 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 Ferdinand; -impl Body for Ferdinand { - fn id(&self) -> NaifId { - NaifId(724i32) - } - fn name(&self) -> &'static str { - "Ferdinand" - } -} -impl Display for Ferdinand { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Ferdinand { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] 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 Perdita; -impl Body for Perdita { - fn id(&self) -> NaifId { - NaifId(725i32) - } - fn name(&self) -> &'static str { - "Perdita" - } -} -impl Display for Perdita { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Perdita { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] 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 Mab; -impl Body for Mab { - fn id(&self) -> NaifId { - NaifId(726i32) - } - fn name(&self) -> &'static str { - "Mab" - } -} -impl Display for Mab { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Mab { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] 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 Cupid; -impl Body for Cupid { - fn id(&self) -> NaifId { - NaifId(727i32) - } - fn name(&self) -> &'static str { - "Cupid" - } -} -impl Display for Cupid { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Cupid { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64, - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64, - ] 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 Triton; -impl Satellite for Triton {} -impl Body for Triton { - fn id(&self) -> NaifId { - NaifId(801i32) - } - fn name(&self) -> &'static str { - "Triton" - } -} -impl Display for Triton { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Triton { - fn polar_radius(&self) -> f64 { - 1352.6f64 - } - fn mean_radius(&self) -> f64 { - 1352.6f64 - } -} -impl TriAxial for Triton { - fn subplanetary_radius(&self) -> f64 { - 1352.6f64 - } - fn along_orbit_radius(&self) -> f64 { - 1352.6f64 - } -} -impl PointMass for Triton { - fn gravitational_parameter(&self) -> f64 { - 1428.495462910464f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Triton { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64, - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 5.224817648770225f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.5646140130201657f64, - 0f64, - -0.1096066770252439f64, - -0.03630284844148206f64, - -0.012915436464758038f64, - -0.004886921905584123f64, - -0.0019198621771937625f64, - -0.0012217304763960308f64, - -0.00034906585039886593f64, - -0.00017453292519943296f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7185520530460655f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.3935717463247213f64, - 0f64, - 0.03665191429188092f64, - 0.009599310885968814f64, - 0.0027925268031909274f64, - 0.0008726646259971648f64, - 0.00034906585039886593f64, - 0.00017453292519943296f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 5.175424830938785f64, - -1.069140942327404f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.3883357585687383f64, - 0f64, - 0.11746065865921838f64, - 0.03577924966588375f64, - 0.012915436464758038f64, - 0.004886921905584123f64, - 0.0019198621771937625f64, - 0.0008726646259971648f64, - 0.00034906585039886593f64, - 0.00017453292519943296f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Nereid; -impl Body for Nereid { - fn id(&self) -> NaifId { - NaifId(802i32) - } - fn name(&self) -> &'static str { - "Nereid" - } -} -impl Display for Nereid { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Nereid { - fn polar_radius(&self) -> f64 { - 170f64 - } - fn mean_radius(&self) -> f64 { - 170f64 - } -} -impl TriAxial for Nereid { - fn subplanetary_radius(&self) -> f64 { - 170f64 - } - fn along_orbit_radius(&self) -> f64 { - 170f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Nereid { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64, - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64, - ] 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 Naiad; -impl Satellite for Naiad {} -impl Body for Naiad { - fn id(&self) -> NaifId { - NaifId(803i32) - } - fn name(&self) -> &'static str { - "Naiad" - } -} -impl Display for Naiad { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Naiad { - fn polar_radius(&self) -> f64 { - 29f64 - } - fn mean_radius(&self) -> f64 { - 29f64 - } -} -impl TriAxial for Naiad { - fn subplanetary_radius(&self) -> f64 { - 29f64 - } - fn along_orbit_radius(&self) -> f64 { - 29f64 - } -} -impl PointMass for Naiad { - fn gravitational_parameter(&self) -> f64 { - 0.008530281246540886f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Naiad { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64, - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 5.224817648770225f64, - 0f64, - 0f64, - &[ - 0.012217304763960306f64, - -0.11327186845443199f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.004363323129985824f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7567747636647413f64, - 0f64, - 0f64, - &[ - -0.00890117918517108f64, - -0.08290313946973066f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0015707963267948964f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 4.434183497616794f64, - 21.342656148360604f64, - 0f64, - &[ - -0.008377580409572781f64, - 0.07679448708775051f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.00471238898038469f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Thalassa; -impl Satellite for Thalassa {} -impl Body for Thalassa { - fn id(&self) -> NaifId { - NaifId(804i32) - } - fn name(&self) -> &'static str { - "Thalassa" - } -} -impl Display for Thalassa { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Thalassa { - fn polar_radius(&self) -> f64 { - 40f64 - } - fn mean_radius(&self) -> f64 { - 40f64 - } -} -impl TriAxial for Thalassa { - fn subplanetary_radius(&self) -> f64 { - 40f64 - } - fn along_orbit_radius(&self) -> f64 { - 40f64 - } -} -impl PointMass for Thalassa { - fn gravitational_parameter(&self) -> f64 { - 0.0235887319799217f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Thalassa { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64, - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 5.224817648770225f64, - 0f64, - 0f64, - &[ - 0.012217304763960306f64, - 0f64, - -0.004886921905584123f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7583455599915362f64, - 0f64, - 0f64, - &[ - -0.00890117918517108f64, - 0f64, - -0.003665191429188092f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 1.7812830345854127f64, - 20.171739891174827f64, - 0f64, - &[ - -0.008377580409572781f64, - 0f64, - 0.0033161255787892262f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Despina; -impl Satellite for Despina {} -impl Body for Despina { - fn id(&self) -> NaifId { - NaifId(805i32) - } - fn name(&self) -> &'static str { - "Despina" - } -} -impl Display for Despina { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Despina { - fn polar_radius(&self) -> f64 { - 74f64 - } - fn mean_radius(&self) -> f64 { - 74f64 - } -} -impl TriAxial for Despina { - fn subplanetary_radius(&self) -> f64 { - 74f64 - } - fn along_orbit_radius(&self) -> f64 { - 74f64 - } -} -impl PointMass for Despina { - fn gravitational_parameter(&self) -> f64 { - 0.1167318403814998f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Despina { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64, - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 5.224817648770225f64, - 0f64, - 0f64, - &[ - 0.012217304763960306f64, - 0f64, - 0f64, - -0.0015707963267948964f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7583455599915362f64, - 0f64, - 0f64, - &[ - -0.00890117918517108f64, - 0f64, - 0f64, - -0.0012217304763960308f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 5.34960869028782f64, - 18.77510290185297f64, - 0f64, - &[ - -0.008552113334772215f64, - 0f64, - 0f64, - 0.0010471975511965976f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Galatea; -impl Satellite for Galatea {} -impl Body for Galatea { - fn id(&self) -> NaifId { - NaifId(806i32) - } - fn name(&self) -> &'static str { - "Galatea" - } -} -impl Display for Galatea { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Galatea { - fn polar_radius(&self) -> f64 { - 79f64 - } - fn mean_radius(&self) -> f64 { - 79f64 - } -} -impl TriAxial for Galatea { - fn subplanetary_radius(&self) -> f64 { - 79f64 - } - fn along_orbit_radius(&self) -> f64 { - 79f64 - } -} -impl PointMass for Galatea { - fn gravitational_parameter(&self) -> f64 { - 0.189898503906069f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Galatea { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64, - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 5.224817648770225f64, - 0f64, - 0f64, - &[ - 0.012217304763960306f64, - 0f64, - 0f64, - 0f64, - -0.0012217304763960308f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7579964941411373f64, - 0f64, - 0f64, - &[ - -0.00890117918517108f64, - 0f64, - 0f64, - 0f64, - -0.0008726646259971648f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 4.504520266472165f64, - 14.6548275586037f64, - 0f64, - &[ - -0.008377580409572781f64, - 0f64, - 0f64, - 0f64, - 0.0008726646259971648f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Larissa; -impl Satellite for Larissa {} -impl Body for Larissa { - fn id(&self) -> NaifId { - NaifId(807i32) - } - fn name(&self) -> &'static str { - "Larissa" - } -} -impl Display for Larissa { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Larissa { - fn polar_radius(&self) -> f64 { - 96f64 - } - fn mean_radius(&self) -> f64 { - 96f64 - } -} -impl TriAxial for Larissa { - fn subplanetary_radius(&self) -> f64 { - 96f64 - } - fn along_orbit_radius(&self) -> f64 { - 96f64 - } -} -impl PointMass for Larissa { - fn gravitational_parameter(&self) -> f64 { - 0.2548437405693583f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Larissa { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64, - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 5.224817648770225f64, - 0f64, - 0f64, - &[ - 0.012217304763960306f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.00471238898038469f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7576474282907384f64, - 0f64, - 0f64, - &[ - -0.00890117918517108f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.003490658503988659f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 3.1312952110030268f64, - 11.328119671568512f64, - 0f64, - &[ - -0.008377580409572781f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0033161255787892262f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Proteus; -impl Satellite for Proteus {} -impl Body for Proteus { - fn id(&self) -> NaifId { - NaifId(808i32) - } - fn name(&self) -> &'static str { - "Proteus" - } -} -impl Display for Proteus { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Proteus { - fn polar_radius(&self) -> f64 { - 201f64 - } - fn mean_radius(&self) -> f64 { - 209f64 - } -} -impl TriAxial for Proteus { - fn subplanetary_radius(&self) -> f64 { - 218f64 - } - fn along_orbit_radius(&self) -> f64 { - 208f64 - } -} -impl PointMass for Proteus { - fn gravitational_parameter(&self) -> f64 { - 2.583422379120727f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Proteus { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64, - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64, - ] as &[f64], - ) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - ( - 5.22324685244343f64, - 0f64, - 0f64, - &[ - 0.012217304763960306f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0008726646259971648f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 0.7489207820307667f64, - 0f64, - 0f64, - &[ - -0.00890117918517108f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0006981317007977319f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 1.6297884555123048f64, - 5.598412754411688f64, - 0f64, - &[ - -0.008377580409572781f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0006981317007977319f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - ] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Halimede; -impl Body for Halimede { - fn id(&self) -> NaifId { - NaifId(809i32) - } - fn name(&self) -> &'static str { - "Halimede" - } -} -impl Display for Halimede { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Halimede { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64, - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64, - ] 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 Psamathe; -impl Body for Psamathe { - fn id(&self) -> NaifId { - NaifId(810i32) - } - fn name(&self) -> &'static str { - "Psamathe" - } -} -impl Display for Psamathe { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Psamathe { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64, - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64, - ] 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 Sao; -impl Body for Sao { - fn id(&self) -> NaifId { - NaifId(811i32) - } - fn name(&self) -> &'static str { - "Sao" - } -} -impl Display for Sao { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Sao { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64, - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64, - ] 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 Laomedeia; -impl Body for Laomedeia { - fn id(&self) -> NaifId { - NaifId(812i32) - } - fn name(&self) -> &'static str { - "Laomedeia" - } -} -impl Display for Laomedeia { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Laomedeia { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64, - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64, - ] 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 Neso; -impl Body for Neso { - fn id(&self) -> NaifId { - NaifId(813i32) - } - fn name(&self) -> &'static str { - "Neso" - } -} -impl Display for Neso { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Neso { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64, - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64, - ] 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 Charon; -impl Satellite for Charon {} -impl Body for Charon { - fn id(&self) -> NaifId { - NaifId(901i32) - } - fn name(&self) -> &'static str { - "Charon" - } -} -impl Display for Charon { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Charon { - fn polar_radius(&self) -> f64 { - 606f64 - } - fn mean_radius(&self) -> f64 { - 606f64 - } -} -impl TriAxial for Charon { - fn subplanetary_radius(&self) -> f64 { - 606f64 - } - fn along_orbit_radius(&self) -> f64 { - 606f64 - } -} -impl PointMass for Charon { - fn gravitational_parameter(&self) -> f64 { - 105.8799888601881f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Charon { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - (&[] as &[f64], &[] as &[f64]) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - (2.3211657321048187f64, 0f64, 0f64, &[] as &[f64]) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - (-0.10756464180041053f64, 0f64, 0f64, &[] as &[f64]) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 2.1414317257344426f64, - 0.9837115923543857f64, - 0f64, - &[] as &[f64], - ) - } -} -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Nix; -impl Body for Nix { - fn id(&self) -> NaifId { - NaifId(902i32) - } - fn name(&self) -> &'static str { - "Nix" - } -} -impl Display for Nix { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl PointMass for Nix { - fn gravitational_parameter(&self) -> f64 { - 0.00304817564816976f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Nix { - 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 Hydra; -impl Body for Hydra { - fn id(&self) -> NaifId { - NaifId(903i32) - } - fn name(&self) -> &'static str { - "Hydra" - } -} -impl Display for Hydra { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl PointMass for Hydra { - fn gravitational_parameter(&self) -> f64 { - 0.003211039206155255f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Hydra { - 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 Kerberos; -impl Body for Kerberos { - fn id(&self) -> NaifId { - NaifId(904i32) - } - fn name(&self) -> &'static str { - "Kerberos" - } -} -impl Display for Kerberos { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl PointMass for Kerberos { - fn gravitational_parameter(&self) -> f64 { - 0.001110040850536676f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Kerberos { - 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 Styx; -impl Body for Styx { - fn id(&self) -> NaifId { - NaifId(905i32) - } - fn name(&self) -> &'static str { - "Styx" - } -} -impl Display for Styx { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl PointMass for Styx { - fn gravitational_parameter(&self) -> f64 { - 0f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Styx { - 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_301() { - assert_eq!(Moon.id(), NaifId(301i32)); - assert_eq!(Moon.name(), "Moon"); - assert_eq!(format!("{}", Moon), "Moon"); - } - #[test] - fn test_tri_axial_301() { - assert_eq!(Moon.polar_radius(), 1737.4f64); - assert_eq!(Moon.mean_radius(), 1737.4000000000003f64); - assert_eq!(Moon.subplanetary_radius(), 1737.4f64); - assert_eq!(Moon.along_orbit_radius(), 1737.4f64); - } - #[test] - fn test_point_mass_301() { - assert_eq!(Moon.gravitational_parameter(), 4902.80011845755f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_301() { - assert_eq!( - ( - &[ - 2.1824469631563095f64, - 4.364876473020098f64, - 4.537995681525416f64, - 3.0826877913349846f64, - 6.240058221362807f64, - 5.438253962996612f64, - 2.355548718369107f64, - 4.827877416989155f64, - 0.5973563897875792f64, - 0.2641381289968218f64, - 2.0899096062155698f64, - 4.188109526378113f64, - 0.4372573375021394f64 - ] as &[f64], - &[ - -33.781483888495835f64, - -67.56296777699167f64, - 8294.909972626925f64, - 8504.459388212737f64, - 628.3019668015924f64, - 16833.15084472816f64, - 8328.69145651542f64, - 209.54947933396397f64, - 1114.6285779726247f64, - -101.3444516654875f64, - 2.301053255936537f64, - 104.77473966698199f64, - 8261.12848873843f64 - ] as &[f64] - ), - Moon.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_301() { - assert_eq!( - ( - 4.712299968592838f64, - 0.000054105206811824215f64, - 0f64, - &[ - -0.06769608569710406f64, - -0.0021013764194011725f64, - 0.0012217304763960308f64, - -0.0003001966313430247f64, - 0f64, - 0.0001256637061435917f64, - 0f64, - 0f64, - 0f64, - -0.00009075712110370513f64, - 0f64, - 0f64, - 0.00007504915783575618f64 - ] as &[f64] - ), - Moon.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_301() { - assert_eq!( - ( - 1.161328121643011f64, - 0.00022689280275926284f64, - 0f64, - &[ - 0.02691123173650057f64, - 0.0004171336912266448f64, - -0.00048520153205442357f64, - 0.0001186823891356144f64, - 0f64, - -0.00005061454830783555f64, - 0.000015707963267948964f64, - 0f64, - 0f64, - 0.000013962634015954637f64, - 0f64, - 0f64, - -0.000015707963267948964f64 - ] as &[f64] - ), - Moon.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_301() { - assert_eq!( - ( - 0.668832858644503f64, - 0.22997083313948888f64, - -0.000000000000024434609527920614f64, - &[ - 0.06215117466351808f64, - 0.00210835773640915f64, - -0.0011205013797803594f64, - 0.0002757620218151041f64, - 0.0004398229715025711f64, - -0.00011519173063162575f64, - -0.00008203047484373349f64, - -0.00008028514559173915f64, - 0.000048869219055841225f64, - 0.00009075712110370513f64, - 0.00006981317007977319f64, - 0.00003316125578789226f64, - -0.0000767944870877505f64 - ] as &[f64] - ), - Moon.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_401() { - assert_eq!(Phobos.id(), NaifId(401i32)); - assert_eq!(Phobos.name(), "Phobos"); - assert_eq!(format!("{}", Phobos), "Phobos"); - } - #[test] - fn test_tri_axial_401() { - assert_eq!(Phobos.polar_radius(), 9.1f64); - assert_eq!(Phobos.mean_radius(), 11.166666666666666f64); - assert_eq!(Phobos.subplanetary_radius(), 13f64); - assert_eq!(Phobos.along_orbit_radius(), 11.4f64); - } - #[test] - fn test_point_mass_401() { - assert_eq!(Phobos.gravitational_parameter(), 0.0007087546066894452f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_401() { - assert_eq!( - ( - &[ - 3.328804809897935f64, - 0f64, - 555.6129894920322f64, - 5.809517398292802f64, - 0f64, - 668.125936040531f64, - 3.3097152567180146f64, - 0.22186491448462606f64, - 11.523153020184504f64, - 4.032588225058434f64, - 0f64, - 23.047098122619843f64, - 3.8045796985836846f64, - 0f64, - 334.05316148477937f64, - 3.4730520762801462f64, - 0f64, - 668.1268926511307f64, - 4.357448194643978f64, - 0f64, - 1336.235189496269f64, - 1.3857704297725961f64, - 0f64, - 334.054984682245f64, - 0.751510868094019f64, - 0f64, - 1002.1811764929237f64, - 1.3871248750853138f64, - 0f64, - 0.008801023466045386f64, - 2.252727410236719f64, - 0f64, - 668.130317528175f64, - 0.9890544553471146f64, - 0f64, - 1336.2285297823557f64, - 1.8289772979888115f64, - 0f64, - 0.008801023466045386f64 - ] as &[f64], - &[ - 277.80594525842264f64, - 0.37470342287773584f64, - 0f64, - 334.05422022489097f64, - 6.892873571600945f64, - 0f64, - 719340.2120445863f64, - 2.120032883264378f64, - 0f64, - 11.536473384554899f64, - 4.387288948439982f64, - 0f64, - 668.1113614443373f64, - 3.424288764152381f64, - 0f64, - 334.0469780000094f64, - 3.9495523217086292f64, - 0f64, - 1002.1807129125305f64, - 4.645778664015252f64, - 0f64, - 0.008801023466045386f64, - 2.136869016190709f64, - 0f64, - 668.1273150051017f64, - 1.0064158213753553f64, - 0f64, - 1336.2354112473317f64, - 2.9029314796567682f64, - 0f64, - 334.05659172556966f64, - 0.6344650043848296f64, - 0f64, - 1002.1842799588599f64, - 1.1757236496733376f64, - 0f64, - 1670.2877519268022f64, - 1.664898441223219f64, - 0f64 - ] as &[f64] - ), - Phobos.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_401() { - assert_eq!( - ( - 5.544399941316208f64, - -0.001892691938596266f64, - 0f64, - &[ - -0.031141630416121578f64, - 0.00038621064567151f64, - -0.00017946365486924213f64, - -0.00008300698656022431f64 - ] as &[f64] - ), - Phobos.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_401() { - assert_eq!( - ( - 0.9230395870244597f64, - -0.0010707081834185127f64, - 0f64, - &[ - -0.018765175709923063f64, - 0.00011669725164439606f64, - -0.00011322648989388013f64, - 0.000049144282945955534f64 - ] as &[f64] - ), - Phobos.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_401() { - assert_eq!( - ( - 0.6141419961301966f64, - 19.702057793318815f64, - 0.00000000016643698911600935f64, - &[ - 0.02485728795564792f64, - -0.0003968499982587423f64, - 0.0000716825922415843f64, - 0.00011029852554073445f64, - -0.019949113350295186f64 - ] as &[f64] - ), - Phobos.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_402() { - assert_eq!(Deimos.id(), NaifId(402i32)); - assert_eq!(Deimos.name(), "Deimos"); - assert_eq!(format!("{}", Deimos), "Deimos"); - } - #[test] - fn test_tri_axial_402() { - assert_eq!(Deimos.polar_radius(), 5.1f64); - assert_eq!(Deimos.mean_radius(), 6.3f64); - assert_eq!(Deimos.subplanetary_radius(), 7.8f64); - assert_eq!(Deimos.along_orbit_radius(), 6f64); - } - #[test] - fn test_point_mass_402() { - assert_eq!(Deimos.gravitational_parameter(), 0.00009615569648120313f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_402() { - assert_eq!( - ( - &[ - 3.328804809897935f64, - 0f64, - 555.6129894920322f64, - 5.809517398292802f64, - 0f64, - 668.125936040531f64, - 3.3097152567180146f64, - 0.22186491448462606f64, - 11.523153020184504f64, - 4.032588225058434f64, - 0f64, - 23.047098122619843f64, - 3.8045796985836846f64, - 0f64, - 334.05316148477937f64, - 3.4730520762801462f64, - 0f64, - 668.1268926511307f64, - 4.357448194643978f64, - 0f64, - 1336.235189496269f64, - 1.3857704297725961f64, - 0f64, - 334.054984682245f64, - 0.751510868094019f64, - 0f64, - 1002.1811764929237f64, - 1.3871248750853138f64, - 0f64, - 0.008801023466045386f64, - 2.252727410236719f64, - 0f64, - 668.130317528175f64, - 0.9890544553471146f64, - 0f64, - 1336.2285297823557f64, - 1.8289772979888115f64, - 0f64, - 0.008801023466045386f64 - ] as &[f64], - &[ - 277.80594525842264f64, - 0.37470342287773584f64, - 0f64, - 334.05422022489097f64, - 6.892873571600945f64, - 0f64, - 719340.2120445863f64, - 2.120032883264378f64, - 0f64, - 11.536473384554899f64, - 4.387288948439982f64, - 0f64, - 668.1113614443373f64, - 3.424288764152381f64, - 0f64, - 334.0469780000094f64, - 3.9495523217086292f64, - 0f64, - 1002.1807129125305f64, - 4.645778664015252f64, - 0f64, - 0.008801023466045386f64, - 2.136869016190709f64, - 0f64, - 668.1273150051017f64, - 1.0064158213753553f64, - 0f64, - 1336.2354112473317f64, - 2.9029314796567682f64, - 0f64, - 334.05659172556966f64, - 0.6344650043848296f64, - 0f64, - 1002.1842799588599f64, - 1.1757236496733376f64, - 0f64, - 1670.2877519268022f64, - 1.664898441223219f64, - 0f64 - ] as &[f64] - ), - Deimos.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_402() { - assert_eq!( - ( - 5.526708263174914f64, - -0.0018357397507085887f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.05396867424229676f64, - 0.004010877798556321f64, - 0.0011202666329959662f64, - 0.00044218562371099577f64, - 0.00013590791618817245f64 - ] as &[f64] - ), - Deimos.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_402() { - assert_eq!( - ( - 0.9339242922383507f64, - -0.0010435487658623783f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.032102888827614605f64, - 0.002500240004017941f64, - 0.00033360380402252296f64, - -0.0002587607695714273f64, - 0.00003358537079612689f64 - ] as &[f64] - ), - Deimos.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_402() { - assert_eq!( - ( - 1.3857797243489947f64, - 4.977013864082068f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.047814137677880446f64, - -0.006975837721323607f64, - -0.0011455047921115052f64, - -0.0005084039391304362f64, - 0.0002965593651818685f64 - ] as &[f64] - ), - Deimos.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_501() { - assert_eq!(Io.id(), NaifId(501i32)); - assert_eq!(Io.name(), "Io"); - assert_eq!(format!("{}", Io), "Io"); - } - #[test] - fn test_tri_axial_501() { - assert_eq!(Io.polar_radius(), 1815.7f64); - assert_eq!(Io.mean_radius(), 1821.5f64); - assert_eq!(Io.subplanetary_radius(), 1829.4f64); - assert_eq!(Io.along_orbit_radius(), 1819.4f64); - } - #[test] - fn test_point_mass_501() { - assert_eq!(Io.gravitational_parameter(), 5959.915466180539f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_501() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Io.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_501() { - assert_eq!( - ( - 4.678355059970801f64, - -0.00015707963267948965f64, - 0f64, - &[ - 0f64, - 0f64, - 0.0016406094968746698f64, - 0.0004188790204786391f64 - ] as &[f64] - ), - Io.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_501() { - assert_eq!( - ( - 1.1257373675363425f64, - 0.00005235987755982989f64, - 0f64, - &[ - 0f64, - 0f64, - 0.0006981317007977319f64, - 0.00019198621771937625f64 - ] as &[f64] - ), - Io.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_501() { - assert_eq!( - ( - 3.4974652880714365f64, - 3.551552235248627f64, - 0f64, - &[ - 0f64, - 0f64, - -0.0014835298641951802f64, - -0.0003839724354387525f64 - ] as &[f64] - ), - Io.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_502() { - assert_eq!(Europa.id(), NaifId(502i32)); - assert_eq!(Europa.name(), "Europa"); - assert_eq!(format!("{}", Europa), "Europa"); - } - #[test] - fn test_tri_axial_502() { - assert_eq!(Europa.polar_radius(), 1559.5f64); - assert_eq!(Europa.mean_radius(), 1560.8f64); - assert_eq!(Europa.subplanetary_radius(), 1562.6f64); - assert_eq!(Europa.along_orbit_radius(), 1560.3f64); - } - #[test] - fn test_point_mass_502() { - assert_eq!(Europa.gravitational_parameter(), 3202.712099607295f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_502() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Europa.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_502() { - assert_eq!( - ( - 4.678878658746398f64, - -0.00015707963267948965f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0.01895427567665842f64, - 0.0010471975511965976f64, - 0.0002617993877991494f64, - 0.00015707963267948965f64 - ] as &[f64] - ), - Europa.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_502() { - assert_eq!( - ( - 1.125911900461542f64, - 0.00005235987755982989f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0.008168140899333463f64, - 0.0004537856055185257f64, - 0.00012217304763960306f64, - 0.00003490658503988659f64 - ] as &[f64] - ), - Europa.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_502() { - assert_eq!( - ( - 0.6287025031533974f64, - 1.7693227033738699f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - -0.01710422666954443f64, - -0.0009424777960769379f64, - -0.0002443460952792061f64, - -0.00013962634015954637f64 - ] as &[f64] - ), - Europa.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_503() { - assert_eq!(Ganymede.id(), NaifId(503i32)); - assert_eq!(Ganymede.name(), "Ganymede"); - assert_eq!(format!("{}", Ganymede), "Ganymede"); - } - #[test] - fn test_tri_axial_503() { - assert_eq!(Ganymede.polar_radius(), 2631.2f64); - assert_eq!(Ganymede.mean_radius(), 2631.2f64); - assert_eq!(Ganymede.subplanetary_radius(), 2631.2f64); - assert_eq!(Ganymede.along_orbit_radius(), 2631.2f64); - } - #[test] - fn test_point_mass_503() { - assert_eq!(Ganymede.gravitational_parameter(), 9887.832752719638f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_503() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Ganymede.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_503() { - assert_eq!( - ( - 4.680973053848792f64, - -0.00015707963267948965f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - -0.0006457718232379018f64, - 0.0075223690760955605f64, - 0.0015882496193148398f64 - ] as &[f64] - ), - Ganymede.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_503() { - assert_eq!( - ( - 1.1269590980127384f64, - 0.00005235987755982989f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - -0.00027925268031909274f64, - 0.003246312408709453f64, - 0.0006806784082777885f64 - ] as &[f64] - ), - Ganymede.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_503() { - assert_eq!( - ( - 0.7690618815987814f64, - 0.8782079330731682f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0.0005759586531581288f64, - -0.006789330790257942f64, - -0.0014311699866353504f64 - ] as &[f64] - ), - Ganymede.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_504() { - assert_eq!(Callisto.id(), NaifId(504i32)); - assert_eq!(Callisto.name(), "Callisto"); - assert_eq!(format!("{}", Callisto), "Callisto"); - } - #[test] - fn test_tri_axial_504() { - assert_eq!(Callisto.polar_radius(), 2410.3f64); - assert_eq!(Callisto.mean_radius(), 2410.3f64); - assert_eq!(Callisto.subplanetary_radius(), 2410.3f64); - assert_eq!(Callisto.along_orbit_radius(), 2410.3f64); - } - #[test] - fn test_point_mass_504() { - assert_eq!(Callisto.gravitational_parameter(), 7179.283402579837f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_504() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Callisto.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_504() { - assert_eq!( - ( - 4.690048765959163f64, - -0.00015707963267948965f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - -0.001186823891356144f64, - 0.010297442586766544f64, - 0f64, - 0.00017453292519943296f64 - ] as &[f64] - ), - Callisto.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_504() { - assert_eq!( - ( - 1.1314969540679238f64, - 0.00005235987755982989f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - -0.0005061454830783556f64, - 0.004433136300065597f64, - 0f64, - -0.00006981317007977319f64 - ] as &[f64] - ), - Callisto.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_504() { - assert_eq!( - ( - 4.529303941850484f64, - 0.37648622085811195f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0.001064650843716541f64, - -0.009302604913129777f64, - 0f64, - -0.00015707963267948965f64 - ] as &[f64] - ), - Callisto.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_505() { - assert_eq!(Amalthea.id(), NaifId(505i32)); - assert_eq!(Amalthea.name(), "Amalthea"); - assert_eq!(format!("{}", Amalthea), "Amalthea"); - } - #[test] - fn test_tri_axial_505() { - assert_eq!(Amalthea.polar_radius(), 64f64); - assert_eq!(Amalthea.mean_radius(), 87.33333333333333f64); - assert_eq!(Amalthea.subplanetary_radius(), 125f64); - assert_eq!(Amalthea.along_orbit_radius(), 73f64); - } - #[test] - fn test_point_mass_505() { - assert_eq!(Amalthea.gravitational_parameter(), 0.1645634534798259f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_505() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Amalthea.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_505() { - assert_eq!( - ( - 4.678355059970801f64, - -0.00015707963267948965f64, - 0f64, - &[ - -0.014660765716752368f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.00017453292519943296f64, - 0f64 - ] as &[f64] - ), - Amalthea.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_505() { - assert_eq!( - ( - 1.125562834611143f64, - 0.00005235987755982989f64, - 0f64, - &[ - -0.006283185307179586f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Amalthea.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_505() { - assert_eq!( - ( - 4.043404278095263f64, - 12.612298185680531f64, - 0f64, - &[ - 0.013264502315156905f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.00017453292519943296f64, - 0f64 - ] as &[f64] - ), - Amalthea.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_506() { - assert_eq!(Himalia.id(), NaifId(506i32)); - assert_eq!(Himalia.name(), "Himalia"); - assert_eq!(format!("{}", Himalia), "Himalia"); - } - #[test] - fn test_tri_axial_506() { - assert_eq!(Himalia.polar_radius(), 85f64); - assert_eq!(Himalia.mean_radius(), 85f64); - assert_eq!(Himalia.subplanetary_radius(), 85f64); - assert_eq!(Himalia.along_orbit_radius(), 85f64); - } - #[test] - fn test_point_mass_506() { - assert_eq!(Himalia.gravitational_parameter(), 0.1515524299611265f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_506() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] 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_body_507() { - assert_eq!(Elara.id(), NaifId(507i32)); - assert_eq!(Elara.name(), "Elara"); - assert_eq!(format!("{}", Elara), "Elara"); - } - #[test] - fn test_tri_axial_507() { - assert_eq!(Elara.polar_radius(), 40f64); - assert_eq!(Elara.mean_radius(), 40f64); - assert_eq!(Elara.subplanetary_radius(), 40f64); - assert_eq!(Elara.along_orbit_radius(), 40f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_507() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] 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_body_508() { - assert_eq!(Pasiphae.id(), NaifId(508i32)); - assert_eq!(Pasiphae.name(), "Pasiphae"); - assert_eq!(format!("{}", Pasiphae), "Pasiphae"); - } - #[test] - fn test_tri_axial_508() { - assert_eq!(Pasiphae.polar_radius(), 18f64); - assert_eq!(Pasiphae.mean_radius(), 18f64); - assert_eq!(Pasiphae.subplanetary_radius(), 18f64); - assert_eq!(Pasiphae.along_orbit_radius(), 18f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_508() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] 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_body_509() { - assert_eq!(Sinope.id(), NaifId(509i32)); - assert_eq!(Sinope.name(), "Sinope"); - assert_eq!(format!("{}", Sinope), "Sinope"); - } - #[test] - fn test_tri_axial_509() { - assert_eq!(Sinope.polar_radius(), 14f64); - assert_eq!(Sinope.mean_radius(), 14f64); - assert_eq!(Sinope.subplanetary_radius(), 14f64); - assert_eq!(Sinope.along_orbit_radius(), 14f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_509() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] 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_body_510() { - assert_eq!(Lysithea.id(), NaifId(510i32)); - assert_eq!(Lysithea.name(), "Lysithea"); - assert_eq!(format!("{}", Lysithea), "Lysithea"); - } - #[test] - fn test_tri_axial_510() { - assert_eq!(Lysithea.polar_radius(), 12f64); - assert_eq!(Lysithea.mean_radius(), 12f64); - assert_eq!(Lysithea.subplanetary_radius(), 12f64); - assert_eq!(Lysithea.along_orbit_radius(), 12f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_510() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] 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_body_511() { - assert_eq!(Carme.id(), NaifId(511i32)); - assert_eq!(Carme.name(), "Carme"); - assert_eq!(format!("{}", Carme), "Carme"); - } - #[test] - fn test_tri_axial_511() { - assert_eq!(Carme.polar_radius(), 15f64); - assert_eq!(Carme.mean_radius(), 15f64); - assert_eq!(Carme.subplanetary_radius(), 15f64); - assert_eq!(Carme.along_orbit_radius(), 15f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_511() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] 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_body_512() { - assert_eq!(Ananke.id(), NaifId(512i32)); - assert_eq!(Ananke.name(), "Ananke"); - assert_eq!(format!("{}", Ananke), "Ananke"); - } - #[test] - fn test_tri_axial_512() { - assert_eq!(Ananke.polar_radius(), 10f64); - assert_eq!(Ananke.mean_radius(), 10f64); - assert_eq!(Ananke.subplanetary_radius(), 10f64); - assert_eq!(Ananke.along_orbit_radius(), 10f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_512() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] 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_body_513() { - assert_eq!(Leda.id(), NaifId(513i32)); - assert_eq!(Leda.name(), "Leda"); - assert_eq!(format!("{}", Leda), "Leda"); - } - #[test] - fn test_tri_axial_513() { - assert_eq!(Leda.polar_radius(), 5f64); - assert_eq!(Leda.mean_radius(), 5f64); - assert_eq!(Leda.subplanetary_radius(), 5f64); - assert_eq!(Leda.along_orbit_radius(), 5f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_513() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] 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_body_514() { - assert_eq!(Thebe.id(), NaifId(514i32)); - assert_eq!(Thebe.name(), "Thebe"); - assert_eq!(format!("{}", Thebe), "Thebe"); - } - #[test] - fn test_tri_axial_514() { - assert_eq!(Thebe.polar_radius(), 42f64); - assert_eq!(Thebe.mean_radius(), 49.666666666666664f64); - assert_eq!(Thebe.subplanetary_radius(), 58f64); - assert_eq!(Thebe.along_orbit_radius(), 49f64); - } - #[test] - fn test_point_mass_514() { - assert_eq!(Thebe.gravitational_parameter(), 0.030148f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_514() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Thebe.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_514() { - assert_eq!( - ( - 4.678355059970801f64, - -0.00015707963267948965f64, - 0f64, - &[ - 0f64, - -0.03682644721708035f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0006981317007977319f64 - ] as &[f64] - ), - Thebe.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_514() { - assert_eq!( - ( - 1.125562834611143f64, - 0.00005235987755982989f64, - 0f64, - &[ - 0f64, - -0.0158824961931484f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.00017453292519943296f64 - ] as &[f64] - ), - Thebe.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_514() { - assert_eq!( - ( - 0.1494001839707146f64, - 9.31482937374367f64, - 0f64, - &[ - 0f64, - 0.033335788713091695f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0006981317007977319f64 - ] as &[f64] - ), - Thebe.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_515() { - assert_eq!(Adrastea.id(), NaifId(515i32)); - assert_eq!(Adrastea.name(), "Adrastea"); - assert_eq!(format!("{}", Adrastea), "Adrastea"); - } - #[test] - fn test_tri_axial_515() { - assert_eq!(Adrastea.polar_radius(), 7f64); - assert_eq!(Adrastea.mean_radius(), 8.333333333333334f64); - assert_eq!(Adrastea.subplanetary_radius(), 10f64); - assert_eq!(Adrastea.along_orbit_radius(), 8f64); - } - #[test] - fn test_point_mass_515() { - assert_eq!(Adrastea.gravitational_parameter(), 0.000139f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_515() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Adrastea.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_515() { - assert_eq!( - ( - 4.678355059970801f64, - -0.00015707963267948965f64, - 0f64, - &[] as &[f64] - ), - Adrastea.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_515() { - assert_eq!( - ( - 1.125562834611143f64, - 0.00005235987755982989f64, - 0f64, - &[] as &[f64] - ), - Adrastea.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_515() { - assert_eq!( - ( - 0.5810201079889122f64, - 21.066100687650238f64, - 0f64, - &[] as &[f64] - ), - Adrastea.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_516() { - assert_eq!(Metis.id(), NaifId(516i32)); - assert_eq!(Metis.name(), "Metis"); - assert_eq!(format!("{}", Metis), "Metis"); - } - #[test] - fn test_tri_axial_516() { - assert_eq!(Metis.polar_radius(), 17f64); - assert_eq!(Metis.mean_radius(), 22.333333333333332f64); - assert_eq!(Metis.subplanetary_radius(), 30f64); - assert_eq!(Metis.along_orbit_radius(), 20f64); - } - #[test] - fn test_point_mass_516() { - assert_eq!(Metis.gravitational_parameter(), 0.002501f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_516() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Metis.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_516() { - assert_eq!( - ( - 4.678355059970801f64, - -0.00015707963267948965f64, - 0f64, - &[] as &[f64] - ), - Metis.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_516() { - assert_eq!( - ( - 1.125562834611143f64, - 0.00005235987755982989f64, - 0f64, - &[] as &[f64] - ), - Metis.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_516() { - assert_eq!( - ( - 6.040410008227175f64, - 21.3149160457997f64, - 0f64, - &[] as &[f64] - ), - Metis.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_517() { - assert_eq!(Callirrhoe.id(), NaifId(517i32)); - assert_eq!(Callirrhoe.name(), "Callirrhoe"); - assert_eq!(format!("{}", Callirrhoe), "Callirrhoe"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_517() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Callirrhoe.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_517() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Callirrhoe.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_517() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Callirrhoe.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_517() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Callirrhoe.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_518() { - assert_eq!(Themisto.id(), NaifId(518i32)); - assert_eq!(Themisto.name(), "Themisto"); - assert_eq!(format!("{}", Themisto), "Themisto"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_518() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Themisto.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_518() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Themisto.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_518() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Themisto.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_518() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Themisto.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_519() { - assert_eq!(Magaclite.id(), NaifId(519i32)); - assert_eq!(Magaclite.name(), "Magaclite"); - assert_eq!(format!("{}", Magaclite), "Magaclite"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_519() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Magaclite.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_519() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Magaclite.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_519() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Magaclite.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_519() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Magaclite.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_520() { - assert_eq!(Taygete.id(), NaifId(520i32)); - assert_eq!(Taygete.name(), "Taygete"); - assert_eq!(format!("{}", Taygete), "Taygete"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_520() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Taygete.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_520() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Taygete.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_520() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Taygete.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_520() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Taygete.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_521() { - assert_eq!(Chaldene.id(), NaifId(521i32)); - assert_eq!(Chaldene.name(), "Chaldene"); - assert_eq!(format!("{}", Chaldene), "Chaldene"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_521() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Chaldene.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_521() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Chaldene.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_521() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Chaldene.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_521() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Chaldene.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_522() { - assert_eq!(Harpalyke.id(), NaifId(522i32)); - assert_eq!(Harpalyke.name(), "Harpalyke"); - assert_eq!(format!("{}", Harpalyke), "Harpalyke"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_522() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Harpalyke.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_522() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Harpalyke.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_522() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Harpalyke.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_522() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Harpalyke.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_523() { - assert_eq!(Kalyke.id(), NaifId(523i32)); - assert_eq!(Kalyke.name(), "Kalyke"); - assert_eq!(format!("{}", Kalyke), "Kalyke"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_523() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Kalyke.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_523() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Kalyke.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_523() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Kalyke.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_523() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Kalyke.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_524() { - assert_eq!(Iocaste.id(), NaifId(524i32)); - assert_eq!(Iocaste.name(), "Iocaste"); - assert_eq!(format!("{}", Iocaste), "Iocaste"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_524() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Iocaste.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_524() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Iocaste.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_524() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Iocaste.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_524() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Iocaste.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_525() { - assert_eq!(Erinome.id(), NaifId(525i32)); - assert_eq!(Erinome.name(), "Erinome"); - assert_eq!(format!("{}", Erinome), "Erinome"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_525() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Erinome.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_525() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Erinome.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_525() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Erinome.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_525() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Erinome.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_526() { - assert_eq!(Isonoe.id(), NaifId(526i32)); - assert_eq!(Isonoe.name(), "Isonoe"); - assert_eq!(format!("{}", Isonoe), "Isonoe"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_526() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Isonoe.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_526() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Isonoe.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_526() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Isonoe.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_526() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Isonoe.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_527() { - assert_eq!(Praxidike.id(), NaifId(527i32)); - assert_eq!(Praxidike.name(), "Praxidike"); - assert_eq!(format!("{}", Praxidike), "Praxidike"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_527() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Praxidike.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_527() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Praxidike.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_527() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Praxidike.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_527() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Praxidike.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_528() { - assert_eq!(Autonoe.id(), NaifId(528i32)); - assert_eq!(Autonoe.name(), "Autonoe"); - assert_eq!(format!("{}", Autonoe), "Autonoe"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_528() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Autonoe.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_528() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Autonoe.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_528() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Autonoe.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_528() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Autonoe.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_529() { - assert_eq!(Thyone.id(), NaifId(529i32)); - assert_eq!(Thyone.name(), "Thyone"); - assert_eq!(format!("{}", Thyone), "Thyone"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_529() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Thyone.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_529() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Thyone.right_ascension_coefficients() - ) - } - #[test] - 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_529() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Thyone.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_530() { - assert_eq!(Hermippe.id(), NaifId(530i32)); - assert_eq!(Hermippe.name(), "Hermippe"); - assert_eq!(format!("{}", Hermippe), "Hermippe"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_530() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Hermippe.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_530() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Hermippe.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_530() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Hermippe.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_530() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Hermippe.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_531() { - assert_eq!(Aitne.id(), NaifId(531i32)); - assert_eq!(Aitne.name(), "Aitne"); - assert_eq!(format!("{}", Aitne), "Aitne"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_531() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Aitne.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_531() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Aitne.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_531() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Aitne.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_531() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Aitne.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_532() { - assert_eq!(Eurydome.id(), NaifId(532i32)); - assert_eq!(Eurydome.name(), "Eurydome"); - assert_eq!(format!("{}", Eurydome), "Eurydome"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_532() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Eurydome.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_532() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Eurydome.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_532() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Eurydome.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_532() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Eurydome.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_533() { - assert_eq!(Euanthe.id(), NaifId(533i32)); - assert_eq!(Euanthe.name(), "Euanthe"); - assert_eq!(format!("{}", Euanthe), "Euanthe"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_533() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Euanthe.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_533() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Euanthe.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_533() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Euanthe.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_533() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Euanthe.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_534() { - assert_eq!(Euporie.id(), NaifId(534i32)); - assert_eq!(Euporie.name(), "Euporie"); - assert_eq!(format!("{}", Euporie), "Euporie"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_534() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Euporie.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_534() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Euporie.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_534() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Euporie.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_534() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Euporie.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_535() { - assert_eq!(Orthosie.id(), NaifId(535i32)); - assert_eq!(Orthosie.name(), "Orthosie"); - assert_eq!(format!("{}", Orthosie), "Orthosie"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_535() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Orthosie.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_535() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Orthosie.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_535() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Orthosie.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_535() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Orthosie.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_536() { - assert_eq!(Sponde.id(), NaifId(536i32)); - assert_eq!(Sponde.name(), "Sponde"); - assert_eq!(format!("{}", Sponde), "Sponde"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_536() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Sponde.nutation_precession_coefficients() - ) - } - #[test] - 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_536() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Sponde.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_536() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Sponde.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_537() { - assert_eq!(Kale.id(), NaifId(537i32)); - assert_eq!(Kale.name(), "Kale"); - assert_eq!(format!("{}", Kale), "Kale"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_537() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Kale.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_537() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Kale.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_537() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Kale.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_537() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Kale.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_538() { - assert_eq!(Pasithee.id(), NaifId(538i32)); - assert_eq!(Pasithee.name(), "Pasithee"); - assert_eq!(format!("{}", Pasithee), "Pasithee"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_538() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Pasithee.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_538() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Pasithee.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_538() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Pasithee.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_538() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Pasithee.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_539() { - assert_eq!(Hegemone.id(), NaifId(539i32)); - assert_eq!(Hegemone.name(), "Hegemone"); - assert_eq!(format!("{}", Hegemone), "Hegemone"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_539() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Hegemone.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_539() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Hegemone.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_539() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Hegemone.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_539() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Hegemone.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_540() { - assert_eq!(Mneme.id(), NaifId(540i32)); - assert_eq!(Mneme.name(), "Mneme"); - assert_eq!(format!("{}", Mneme), "Mneme"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_540() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Mneme.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_540() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Mneme.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_540() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Mneme.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_540() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Mneme.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_541() { - assert_eq!(Aoede.id(), NaifId(541i32)); - assert_eq!(Aoede.name(), "Aoede"); - assert_eq!(format!("{}", Aoede), "Aoede"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_541() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Aoede.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_541() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Aoede.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_541() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Aoede.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_541() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Aoede.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_542() { - assert_eq!(Thelxinoe.id(), NaifId(542i32)); - assert_eq!(Thelxinoe.name(), "Thelxinoe"); - assert_eq!(format!("{}", Thelxinoe), "Thelxinoe"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_542() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Thelxinoe.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_542() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Thelxinoe.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_542() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Thelxinoe.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_542() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Thelxinoe.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_543() { - assert_eq!(Arche.id(), NaifId(543i32)); - assert_eq!(Arche.name(), "Arche"); - assert_eq!(format!("{}", Arche), "Arche"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_543() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Arche.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_543() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Arche.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_543() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Arche.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_543() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Arche.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_544() { - assert_eq!(Kallichore.id(), NaifId(544i32)); - assert_eq!(Kallichore.name(), "Kallichore"); - assert_eq!(format!("{}", Kallichore), "Kallichore"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_544() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Kallichore.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_544() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Kallichore.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_544() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Kallichore.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_544() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Kallichore.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_545() { - assert_eq!(Helike.id(), NaifId(545i32)); - assert_eq!(Helike.name(), "Helike"); - assert_eq!(format!("{}", Helike), "Helike"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_545() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Helike.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_545() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Helike.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_545() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Helike.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_545() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Helike.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_546() { - assert_eq!(Carpo.id(), NaifId(546i32)); - assert_eq!(Carpo.name(), "Carpo"); - assert_eq!(format!("{}", Carpo), "Carpo"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_546() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Carpo.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_546() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Carpo.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_546() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Carpo.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_546() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Carpo.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_547() { - assert_eq!(Eukelade.id(), NaifId(547i32)); - assert_eq!(Eukelade.name(), "Eukelade"); - assert_eq!(format!("{}", Eukelade), "Eukelade"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_547() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Eukelade.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_547() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Eukelade.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_547() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Eukelade.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_547() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Eukelade.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_548() { - assert_eq!(Cyllene.id(), NaifId(548i32)); - assert_eq!(Cyllene.name(), "Cyllene"); - assert_eq!(format!("{}", Cyllene), "Cyllene"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_548() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Cyllene.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_548() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Cyllene.right_ascension_coefficients() - ) - } - #[test] - 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_548() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Cyllene.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_549() { - assert_eq!(Kore.id(), NaifId(549i32)); - assert_eq!(Kore.name(), "Kore"); - assert_eq!(format!("{}", Kore), "Kore"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_549() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Kore.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_549() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Kore.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_549() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Kore.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_549() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Kore.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_550() { - assert_eq!(Herse.id(), NaifId(550i32)); - assert_eq!(Herse.name(), "Herse"); - assert_eq!(format!("{}", Herse), "Herse"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_550() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Herse.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_550() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Herse.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_550() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Herse.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_550() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Herse.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_553() { - assert_eq!(Dia.id(), NaifId(553i32)); - assert_eq!(Dia.name(), "Dia"); - assert_eq!(format!("{}", Dia), "Dia"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_553() { - assert_eq!( - ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64 - ] as &[f64], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64 - ] as &[f64] - ), - Dia.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_553() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Dia.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_553() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Dia.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_553() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Dia.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_601() { - assert_eq!(Mimas.id(), NaifId(601i32)); - assert_eq!(Mimas.name(), "Mimas"); - assert_eq!(format!("{}", Mimas), "Mimas"); - } - #[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); - } - #[test] - fn test_point_mass_601() { - assert_eq!(Mimas.gravitational_parameter(), 2.503488768152587f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_601() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] as &[f64] - ), - Mimas.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_601() { - assert_eq!( - ( - 0.7096508738608943f64, - -0.0006283185307179586f64, - 0f64, - &[ - 0f64, - 0f64, - 0.2366666465704311f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Mimas.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_601() { - assert_eq!( - ( - 1.457698991265664f64, - -0.00006981317007977319f64, - 0f64, - &[ - 0f64, - 0f64, - -0.026703537555513242f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Mimas.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_601() { - assert_eq!( - ( - 5.819974923700291f64, - 6.667062709440567f64, - 0f64, - &[ - 0f64, - 0f64, - -0.23527038316883564f64, - 0f64, - -0.7827801695194568f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Mimas.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_602() { - assert_eq!(Enceladus.id(), NaifId(602i32)); - assert_eq!(Enceladus.name(), "Enceladus"); - assert_eq!(format!("{}", Enceladus), "Enceladus"); - } - #[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); - } - #[test] - fn test_point_mass_602() { - assert_eq!(Enceladus.gravitational_parameter(), 7.210366688598896f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_602() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] as &[f64] - ), - Enceladus.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_602() { - assert_eq!( - ( - 0.7096508738608943f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64] - ), - Enceladus.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_602() { - assert_eq!( - ( - 1.457698991265664f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64] - ), - Enceladus.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_602() { - assert_eq!( - ( - 0.11030480872604163f64, - 4.585536698039173f64, - 0f64, - &[] as &[f64] - ), - Enceladus.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_603() { - assert_eq!(Tethys.id(), NaifId(603i32)); - assert_eq!(Tethys.name(), "Tethys"); - assert_eq!(format!("{}", Tethys), "Tethys"); - } - #[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); - } - #[test] - fn test_point_mass_603() { - assert_eq!(Tethys.gravitational_parameter(), 41.21352885489587f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_603() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] as &[f64] - ), - Tethys.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_603() { - assert_eq!( - ( - 0.7096508738608943f64, - -0.0006283185307179586f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0.16859880574265224f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Tethys.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_603() { - assert_eq!( - ( - 1.457698991265664f64, - -0.00006981317007977319f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - -0.019024088846738195f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Tethys.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_603() { - assert_eq!( - ( - 0.1562069680534925f64, - 3.328306379991881f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - -0.16755160819145562f64, - 0.03892084231947355f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Tethys.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_604() { - assert_eq!(Dione.id(), NaifId(604i32)); - assert_eq!(Dione.name(), "Dione"); - assert_eq!(format!("{}", Dione), "Dione"); - } - #[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); - } - #[test] - fn test_point_mass_604() { - assert_eq!(Dione.gravitational_parameter(), 73.11607172482067f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_604() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] as &[f64] - ), - Dione.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_604() { - assert_eq!( - ( - 0.7096508738608943f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64] - ), - Dione.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_604() { - assert_eq!( - ( - 1.457698991265664f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64] - ), - Dione.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_604() { - assert_eq!( - ( - 6.241297405131723f64, - 2.295717637805533f64, - 0f64, - &[] as &[f64] - ), - Dione.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_605() { - assert_eq!(Rhea.id(), NaifId(605i32)); - assert_eq!(Rhea.name(), "Rhea"); - assert_eq!(format!("{}", Rhea), "Rhea"); - } - #[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); - } - #[test] - fn test_point_mass_605() { - assert_eq!(Rhea.gravitational_parameter(), 153.9417519146563f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_605() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] as &[f64] - ), - Rhea.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_605() { - assert_eq!( - ( - 0.7047639519553103f64, - -0.0006283185307179586f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.054105206811824215f64, - 0f64, - 0f64 - ] as &[f64] - ), - Rhea.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_605() { - assert_eq!( - ( - 1.4582225900412622f64, - -0.00006981317007977319f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.006108652381980153f64, - 0f64, - 0f64 - ] as &[f64] - ), - Rhea.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_605() { - assert_eq!( - ( - 4.104316268989865f64, - 1.3908537151816638f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.05375614096142535f64, - 0f64, - 0f64 - ] as &[f64] - ), - Rhea.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_606() { - assert_eq!(Titan.id(), NaifId(606i32)); - assert_eq!(Titan.name(), "Titan"); - assert_eq!(format!("{}", Titan), "Titan"); - } - #[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); - } - #[test] - fn test_point_mass_606() { - assert_eq!(Titan.gravitational_parameter(), 8978.137095521046f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_606() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] as &[f64] - ), - Titan.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_606() { - assert_eq!( - ( - 0.6891031125771652f64, - 0f64, - 0f64, - &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64] - ), - Titan.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_606() { - assert_eq!( - ( - 1.456091543024577f64, - 0f64, - 0f64, - &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64] - ), - Titan.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_606() { - assert_eq!( - ( - 3.2565313114798795f64, - 0.39404258030637335f64, - 0f64, - &[0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64] as &[f64] - ), - Titan.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_607() { - assert_eq!(Hyperion.id(), NaifId(607i32)); - assert_eq!(Hyperion.name(), "Hyperion"); - assert_eq!(format!("{}", Hyperion), "Hyperion"); - } - #[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); - } - #[test] - fn test_point_mass_607() { - assert_eq!(Hyperion.gravitational_parameter(), 0.3704913747932265f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_607() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_608() { - assert_eq!(Iapetus.id(), NaifId(608i32)); - assert_eq!(Iapetus.name(), "Iapetus"); - assert_eq!(format!("{}", Iapetus), "Iapetus"); - } - #[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_point_mass_608() { - assert_eq!(Iapetus.gravitational_parameter(), 120.5151060137642f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_608() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] as &[f64] - ), - Iapetus.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_608() { - assert_eq!( - ( - 5.552939548145159f64, - -0.06892305216125608f64, - 0f64, - &[] as &[f64] - ), - Iapetus.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_608() { - assert_eq!( - ( - 1.3095205377713455f64, - -0.019949113350295186f64, - 0f64, - &[] as &[f64] - ), - Iapetus.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_608() { - assert_eq!( - ( - 6.199409503083858f64, - 0.07920229445458282f64, - 0f64, - &[] as &[f64] - ), - Iapetus.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_609() { - assert_eq!(Phoebe.id(), NaifId(609i32)); - assert_eq!(Phoebe.name(), "Phoebe"); - assert_eq!(format!("{}", Phoebe), "Phoebe"); - } - #[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_point_mass_609() { - assert_eq!(Phoebe.gravitational_parameter(), 0.5547860052791678f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_609() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] as &[f64] - ), - Phoebe.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_609() { - assert_eq!( - (6.229080100367762f64, 0f64, 0f64, &[] as &[f64]), - Phoebe.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_609() { - assert_eq!( - (1.3578661580515883f64, 0f64, 0f64, &[] as &[f64]), - Phoebe.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_609() { - assert_eq!( - ( - 3.116808978211474f64, - 16.26016798998745f64, - 0f64, - &[] as &[f64] - ), - Phoebe.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_610() { - assert_eq!(Janus.id(), NaifId(610i32)); - assert_eq!(Janus.name(), "Janus"); - assert_eq!(format!("{}", Janus), "Janus"); - } - #[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_point_mass_610() { - assert_eq!(Janus.gravitational_parameter(), 0.1265765099012197f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_610() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] as &[f64] - ), - Janus.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_610() { - assert_eq!( - ( - 0.7082546104592989f64, - -0.0006283185307179586f64, - 0f64, - &[ - 0f64, - -0.028326693759867967f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0004014257279586958f64 - ] as &[f64] - ), - Janus.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_610() { - assert_eq!( - ( - 1.457698991265664f64, - -0.00006981317007977319f64, - 0f64, - &[ - 0f64, - -0.003193952531149623f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.000017453292519943296f64 - ] as &[f64] - ), - Janus.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_610() { - assert_eq!( - ( - 1.0267771989482641f64, - 9.044924285944507f64, - 0f64, - &[ - 0f64, - 0.028152160834668535f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0004014257279586958f64 - ] as &[f64] - ), - Janus.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_611() { - assert_eq!(Epimetheus.id(), NaifId(611i32)); - assert_eq!(Epimetheus.name(), "Epimetheus"); - assert_eq!(format!("{}", Epimetheus), "Epimetheus"); - } - #[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_point_mass_611() { - assert_eq!(Epimetheus.gravitational_parameter(), 0.03512333288208074f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_611() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] as &[f64] - ), - Epimetheus.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_611() { - assert_eq!( - ( - 0.7082546104592989f64, - -0.0006283185307179586f64, - 0f64, - &[ - -0.05503023131538121f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0015009831567151233f64, - 0f64 - ] as &[f64] - ), - Epimetheus.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_611() { - assert_eq!( - ( - 1.457698991265664f64, - -0.00006981317007977319f64, - 0f64, - &[ - -0.006213372137099813f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.00008726646259971648f64, - 0f64 - ] as &[f64] - ), - Epimetheus.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_611() { - assert_eq!( - ( - 5.128999072835736f64, - 9.049370273103856f64, - 0f64, - &[ - 0.05468116546498235f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0015009831567151233f64, - 0f64 - ] as &[f64] - ), - Epimetheus.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_612() { - assert_eq!(Helene.id(), NaifId(612i32)); - assert_eq!(Helene.name(), "Helene"); - assert_eq!(format!("{}", Helene), "Helene"); - } - #[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_point_mass_612() { - assert_eq!(Helene.gravitational_parameter(), 0.0004757419551776972f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_612() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] as &[f64] - ), - Helene.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_612() { - assert_eq!( - ( - 0.7129669994396837f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64] - ), - Helene.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_612() { - assert_eq!( - ( - 1.4545573986120743f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64] - ), - Helene.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_612() { - assert_eq!( - ( - 4.278151062488501f64, - 2.297157080652823f64, - 0f64, - &[] as &[f64] - ), - Helene.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_613() { - assert_eq!(Telesto.id(), NaifId(613i32)); - assert_eq!(Telesto.name(), "Telesto"); - assert_eq!(format!("{}", Telesto), "Telesto"); - } - #[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!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] as &[f64] - ), - Telesto.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_613() { - assert_eq!( - ( - 0.8815658051823358f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64] - ), - Telesto.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_613() { - assert_eq!( - ( - 1.4671237692264334f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64] - ), - Telesto.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_613() { - assert_eq!( - ( - 0.9927432785343747f64, - 3.328306811088206f64, - 0f64, - &[] as &[f64] - ), - Telesto.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_614() { - assert_eq!(Calypso.id(), NaifId(614i32)); - assert_eq!(Calypso.name(), "Calypso"); - assert_eq!(format!("{}", Calypso), "Calypso"); - } - #[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!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] as &[f64] - ), - Calypso.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_614() { - assert_eq!( - ( - 0.6354743806511354f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64] - ), - Calypso.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_614() { - assert_eq!( - ( - 1.4842279958959779f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64] - ), - Calypso.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_614() { - assert_eq!( - ( - 2.679254934736495f64, - 3.327893239613983f64, - 0f64, - &[] as &[f64] - ), - Calypso.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_615() { - assert_eq!(Atlas.id(), NaifId(615i32)); - assert_eq!(Atlas.name(), "Atlas"); - assert_eq!(format!("{}", Atlas), "Atlas"); - } - #[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_point_mass_615() { - assert_eq!(Atlas.gravitational_parameter(), 0.0003718871247516475f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_615() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] as &[f64] - ), - Atlas.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_615() { - assert_eq!( - ( - 0.7082546104592989f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64] - ), - Atlas.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_615() { - assert_eq!( - ( - 1.4578735241908636f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64] - ), - Atlas.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_615() { - assert_eq!( - ( - 2.4064599726497815f64, - 10.442409634437194f64, - 0f64, - &[] as &[f64] - ), - Atlas.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_616() { - assert_eq!(Prometheus.id(), NaifId(616i32)); - assert_eq!(Prometheus.name(), "Prometheus"); - assert_eq!(format!("{}", Prometheus), "Prometheus"); - } - #[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_point_mass_616() { - assert_eq!(Prometheus.gravitational_parameter(), 0.0107520800100761f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_616() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] as &[f64] - ), - Prometheus.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_616() { - assert_eq!( - ( - 0.7082546104592989f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64] - ), - Prometheus.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_616() { - assert_eq!( - ( - 1.4578735241908636f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64] - ), - Prometheus.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_616() { - assert_eq!( - ( - 5.1686180468560075f64, - 10.250126710744977f64, - 0f64, - &[] as &[f64] - ), - Prometheus.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_617() { - assert_eq!(Pandora.id(), NaifId(617i32)); - assert_eq!(Pandora.name(), "Pandora"); - assert_eq!(format!("{}", Pandora), "Pandora"); - } - #[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_point_mass_617() { - assert_eq!(Pandora.gravitational_parameter(), 0.009290325122028795f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_617() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] as &[f64] - ), - Pandora.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_617() { - assert_eq!( - ( - 0.7082546104592989f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64] - ), - Pandora.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_617() { - assert_eq!( - ( - 1.4578735241908636f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64] - ), - Pandora.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_617() { - assert_eq!( - ( - 2.8434904173491615f64, - 9.997055714535051f64, - 0f64, - &[] as &[f64] - ), - Pandora.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_618() { - assert_eq!(Pan.id(), NaifId(618i32)); - assert_eq!(Pan.name(), "Pan"); - assert_eq!(format!("{}", Pan), "Pan"); - } - #[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!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] as &[f64] - ), - Pan.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_618() { - assert_eq!( - ( - 0.7086036763096978f64, - -0.0006283185307179586f64, - 0f64, - &[] as &[f64] - ), - Pan.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_618() { - assert_eq!( - ( - 1.457349925415265f64, - -0.00006981317007977319f64, - 0f64, - &[] as &[f64] - ), - Pan.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_618() { - assert_eq!( - ( - 0.8517206749732328f64, - 10.92652906235538f64, - 0f64, - &[] as &[f64] - ), - Pan.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_619() { - assert_eq!(Ymir.id(), NaifId(619i32)); - assert_eq!(Ymir.name(), "Ymir"); - assert_eq!(format!("{}", Ymir), "Ymir"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_619() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_620() { - assert_eq!(Paaliaq.id(), NaifId(620i32)); - assert_eq!(Paaliaq.name(), "Paaliaq"); - assert_eq!(format!("{}", Paaliaq), "Paaliaq"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_620() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_621() { - assert_eq!(Tarvos.id(), NaifId(621i32)); - assert_eq!(Tarvos.name(), "Tarvos"); - assert_eq!(format!("{}", Tarvos), "Tarvos"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_621() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_622() { - assert_eq!(Ijiraq.id(), NaifId(622i32)); - assert_eq!(Ijiraq.name(), "Ijiraq"); - assert_eq!(format!("{}", Ijiraq), "Ijiraq"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_622() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_623() { - assert_eq!(Suttungr.id(), NaifId(623i32)); - assert_eq!(Suttungr.name(), "Suttungr"); - assert_eq!(format!("{}", Suttungr), "Suttungr"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_623() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_624() { - assert_eq!(Kiviuq.id(), NaifId(624i32)); - assert_eq!(Kiviuq.name(), "Kiviuq"); - assert_eq!(format!("{}", Kiviuq), "Kiviuq"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_624() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_625() { - assert_eq!(Mundilfari.id(), NaifId(625i32)); - assert_eq!(Mundilfari.name(), "Mundilfari"); - assert_eq!(format!("{}", Mundilfari), "Mundilfari"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_625() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_626() { - assert_eq!(Albiorix.id(), NaifId(626i32)); - assert_eq!(Albiorix.name(), "Albiorix"); - assert_eq!(format!("{}", Albiorix), "Albiorix"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_626() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_627() { - assert_eq!(Skathi.id(), NaifId(627i32)); - assert_eq!(Skathi.name(), "Skathi"); - assert_eq!(format!("{}", Skathi), "Skathi"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_627() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_628() { - assert_eq!(Erriapus.id(), NaifId(628i32)); - assert_eq!(Erriapus.name(), "Erriapus"); - assert_eq!(format!("{}", Erriapus), "Erriapus"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_628() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_629() { - assert_eq!(Siarnaq.id(), NaifId(629i32)); - assert_eq!(Siarnaq.name(), "Siarnaq"); - assert_eq!(format!("{}", Siarnaq), "Siarnaq"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_629() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_630() { - assert_eq!(Thrymr.id(), NaifId(630i32)); - assert_eq!(Thrymr.name(), "Thrymr"); - assert_eq!(format!("{}", Thrymr), "Thrymr"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_630() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_631() { - assert_eq!(Narvi.id(), NaifId(631i32)); - assert_eq!(Narvi.name(), "Narvi"); - assert_eq!(format!("{}", Narvi), "Narvi"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_631() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_632() { - assert_eq!(Methone.id(), NaifId(632i32)); - assert_eq!(Methone.name(), "Methone"); - assert_eq!(format!("{}", Methone), "Methone"); - } - #[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!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_633() { - assert_eq!(Pallene.id(), NaifId(633i32)); - assert_eq!(Pallene.name(), "Pallene"); - assert_eq!(format!("{}", Pallene), "Pallene"); - } - #[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!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_634() { - assert_eq!(Polydeuces.id(), NaifId(634i32)); - assert_eq!(Polydeuces.name(), "Polydeuces"); - assert_eq!(format!("{}", Polydeuces), "Polydeuces"); - } - #[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!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_635() { - assert_eq!(Daphnis.id(), NaifId(635i32)); - assert_eq!(Daphnis.name(), "Daphnis"); - assert_eq!(format!("{}", Daphnis), "Daphnis"); - } - #[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!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_636() { - assert_eq!(Aegir.id(), NaifId(636i32)); - assert_eq!(Aegir.name(), "Aegir"); - assert_eq!(format!("{}", Aegir), "Aegir"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_636() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_637() { - assert_eq!(Bebhionn.id(), NaifId(637i32)); - assert_eq!(Bebhionn.name(), "Bebhionn"); - assert_eq!(format!("{}", Bebhionn), "Bebhionn"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_637() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_638() { - assert_eq!(Bergelmir.id(), NaifId(638i32)); - assert_eq!(Bergelmir.name(), "Bergelmir"); - assert_eq!(format!("{}", Bergelmir), "Bergelmir"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_638() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_639() { - assert_eq!(Bestla.id(), NaifId(639i32)); - assert_eq!(Bestla.name(), "Bestla"); - assert_eq!(format!("{}", Bestla), "Bestla"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_639() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_640() { - assert_eq!(Farbauti.id(), NaifId(640i32)); - assert_eq!(Farbauti.name(), "Farbauti"); - assert_eq!(format!("{}", Farbauti), "Farbauti"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_640() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_641() { - assert_eq!(Fenrir.id(), NaifId(641i32)); - assert_eq!(Fenrir.name(), "Fenrir"); - assert_eq!(format!("{}", Fenrir), "Fenrir"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_641() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_642() { - assert_eq!(Fornjot.id(), NaifId(642i32)); - assert_eq!(Fornjot.name(), "Fornjot"); - assert_eq!(format!("{}", Fornjot), "Fornjot"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_642() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_643() { - assert_eq!(Hati.id(), NaifId(643i32)); - assert_eq!(Hati.name(), "Hati"); - assert_eq!(format!("{}", Hati), "Hati"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_643() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_644() { - assert_eq!(Hyrrokkin.id(), NaifId(644i32)); - assert_eq!(Hyrrokkin.name(), "Hyrrokkin"); - assert_eq!(format!("{}", Hyrrokkin), "Hyrrokkin"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_644() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_645() { - assert_eq!(Kari.id(), NaifId(645i32)); - assert_eq!(Kari.name(), "Kari"); - assert_eq!(format!("{}", Kari), "Kari"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_645() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_646() { - assert_eq!(Loge.id(), NaifId(646i32)); - assert_eq!(Loge.name(), "Loge"); - assert_eq!(format!("{}", Loge), "Loge"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_646() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_647() { - assert_eq!(Skoll.id(), NaifId(647i32)); - assert_eq!(Skoll.name(), "Skoll"); - assert_eq!(format!("{}", Skoll), "Skoll"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_647() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_648() { - assert_eq!(Surtur.id(), NaifId(648i32)); - assert_eq!(Surtur.name(), "Surtur"); - assert_eq!(format!("{}", Surtur), "Surtur"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_648() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_649() { - assert_eq!(Anthe.id(), NaifId(649i32)); - assert_eq!(Anthe.name(), "Anthe"); - assert_eq!(format!("{}", Anthe), "Anthe"); - } - #[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!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_650() { - assert_eq!(Jarnsaxa.id(), NaifId(650i32)); - assert_eq!(Jarnsaxa.name(), "Jarnsaxa"); - assert_eq!(format!("{}", Jarnsaxa), "Jarnsaxa"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_650() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_651() { - assert_eq!(Greip.id(), NaifId(651i32)); - assert_eq!(Greip.name(), "Greip"); - assert_eq!(format!("{}", Greip), "Greip"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_651() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_652() { - assert_eq!(Tarqeq.id(), NaifId(652i32)); - assert_eq!(Tarqeq.name(), "Tarqeq"); - assert_eq!(format!("{}", Tarqeq), "Tarqeq"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_652() { - assert_eq!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_653() { - assert_eq!(Aegaeon.id(), NaifId(653i32)); - assert_eq!(Aegaeon.name(), "Aegaeon"); - assert_eq!(format!("{}", Aegaeon), "Aegaeon"); - } - #[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!( - ( - &[ - 6.166597313146365f64, - 0.5012585611727715f64, - 3.0962140930379407f64, - 5.235987755982989f64, - 5.523094417936056f64, - 6.0248765778844255f64, - 12.33319462629273f64, - 1.002517122345543f64 - ] as &[f64], - &[ - 1321.331180819591f64, - 1321.331180819591f64, - -637.14117008679f64, - -126.11574641985825f64, - 8.834856673595295f64, - -17.73778118801837f64, - 2642.662361639182f64, - 2642.662361639182f64 - ] 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_body_701() { - assert_eq!(Ariel.id(), NaifId(701i32)); - assert_eq!(Ariel.name(), "Ariel"); - assert_eq!(format!("{}", Ariel), "Ariel"); - } - #[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_point_mass_701() { - assert_eq!(Ariel.gravitational_parameter(), 83.46344431770477f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_701() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Ariel.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_701() { - assert_eq!( - ( - 4.493001093409003f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.005061454830783556f64 - ] as &[f64] - ), - Ariel.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_701() { - assert_eq!( - ( - -0.26354471705114374f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.004886921905584123f64 - ] as &[f64] - ), - Ariel.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_701() { - assert_eq!( - ( - 2.7265533574655416f64, - -2.492952697630833f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0008726646259971648f64, - 0.0013962634015954637f64 - ] as &[f64] - ), - Ariel.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_702() { - assert_eq!(Umbriel.id(), NaifId(702i32)); - assert_eq!(Umbriel.name(), "Umbriel"); - assert_eq!(format!("{}", Umbriel), "Umbriel"); - } - #[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_point_mass_702() { - assert_eq!(Umbriel.gravitational_parameter(), 85.09338094489388f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_702() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Umbriel.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_702() { - assert_eq!( - ( - 4.493001093409003f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.003665191429188092f64 - ] as &[f64] - ), - Umbriel.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_702() { - assert_eq!( - ( - -0.26354471705114374f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.003490658503988659f64 - ] as &[f64] - ), - Umbriel.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_702() { - assert_eq!( - ( - 1.885828256779873f64, - -1.5161481881953498f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0015707963267948964f64, - 0f64, - 0.0010471975511965976f64 - ] as &[f64] - ), - Umbriel.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_703() { - assert_eq!(Titania.id(), NaifId(703i32)); - assert_eq!(Titania.name(), "Titania"); - assert_eq!(format!("{}", Titania), "Titania"); - } - #[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_point_mass_703() { - assert_eq!(Titania.gravitational_parameter(), 226.9437003741248f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_703() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Titania.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_703() { - assert_eq!( - ( - 4.493001093409003f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.005061454830783556f64 - ] as &[f64] - ), - Titania.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_703() { - assert_eq!( - ( - -0.26354471705114374f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.004886921905584123f64 - ] as &[f64] - ), - Titania.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_703() { - assert_eq!( - ( - 1.3568189605003917f64, - -0.7217186318332268f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0013962634015954637f64 - ] as &[f64] - ), - Titania.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_704() { - assert_eq!(Oberon.id(), NaifId(704i32)); - assert_eq!(Oberon.name(), "Oberon"); - assert_eq!(format!("{}", Oberon), "Oberon"); - } - #[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_point_mass_704() { - assert_eq!(Oberon.gravitational_parameter(), 205.3234302535623f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_704() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Oberon.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_704() { - assert_eq!( - ( - 4.493001093409003f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0027925268031909274f64 - ] as &[f64] - ), - Oberon.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_704() { - assert_eq!( - ( - -0.26354471705114374f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0027925268031909274f64 - ] as &[f64] - ), - Oberon.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_704() { - assert_eq!( - ( - 0.1181587903600161f64, - -0.4666921966546346f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0006981317007977319f64 - ] as &[f64] - ), - Oberon.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_705() { - assert_eq!(Miranda.id(), NaifId(705i32)); - assert_eq!(Miranda.name(), "Miranda"); - assert_eq!(format!("{}", Miranda), "Miranda"); - } - #[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_point_mass_705() { - assert_eq!(Miranda.gravitational_parameter(), 4.3195168992321f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_705() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Miranda.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_705() { - assert_eq!( - ( - 4.493001093409003f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.07696902001294993f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0006981317007977319f64, - 0f64 - ] as &[f64] - ), - Miranda.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_705() { - assert_eq!( - ( - -0.2631956512007449f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.07417649320975901f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.00034906585039886593f64, - 0f64 - ] as &[f64] - ), - Miranda.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_705() { - assert_eq!( - ( - 0.5358160803622591f64, - -4.445191100713563f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.02007128639793479f64, - -0.022165681500327987f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0015707963267948964f64, - 0.002617993877991494f64 - ] as &[f64] - ), - Miranda.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_706() { - assert_eq!(Cordelia.id(), NaifId(706i32)); - assert_eq!(Cordelia.name(), "Cordelia"); - assert_eq!(format!("{}", Cordelia), "Cordelia"); - } - #[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!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Cordelia.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_706() { - assert_eq!( - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - -0.002617993877991494f64, - 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!( - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0.0024434609527920616f64, - 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!( - ( - 2.2286109218715593f64, - -18.753921879266084f64, - 0f64, - &[ - -0.0006981317007977319f64, - 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_body_707() { - assert_eq!(Ophelia.id(), NaifId(707i32)); - assert_eq!(Ophelia.name(), "Ophelia"); - assert_eq!(format!("{}", Ophelia), "Ophelia"); - } - #[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!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Ophelia.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_707() { - assert_eq!( - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - 0f64, - -0.0015707963267948964f64, - 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!( - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0f64, - 0.0015707963267948964f64, - 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!( - ( - 2.2750366799746087f64, - -16.692447910262292f64, - 0f64, - &[ - 0f64, - -0.0005235987755982988f64, - 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_body_708() { - assert_eq!(Bianca.id(), NaifId(708i32)); - assert_eq!(Bianca.name(), "Bianca"); - assert_eq!(format!("{}", Bianca), "Bianca"); - } - #[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_nutation_precession_coefficients_708() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Bianca.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_708() { - assert_eq!( - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - -0.0027925268031909274f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Bianca.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_708() { - assert_eq!( - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0.0027925268031909274f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Bianca.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_708() { - assert_eq!( - ( - 1.8406242291532198f64, - -14.458158751655587f64, - 0f64, - &[ - 0f64, - 0f64, - -0.0006981317007977319f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Bianca.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_709() { - assert_eq!(Cressida.id(), NaifId(709i32)); - assert_eq!(Cressida.name(), "Cressida"); - assert_eq!(format!("{}", Cressida), "Cressida"); - } - #[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); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_709() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Cressida.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_709() { - assert_eq!( - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - -0.0006981317007977319f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Cressida.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_709() { - assert_eq!( - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0.0006981317007977319f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Cressida.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_709() { - assert_eq!( - ( - 1.0325367854798453f64, - -13.553906388910956f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - -0.00017453292519943296f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Cressida.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_710() { - assert_eq!(Desdemona.id(), NaifId(710i32)); - assert_eq!(Desdemona.name(), "Desdemona"); - assert_eq!(format!("{}", Desdemona), "Desdemona"); - } - #[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); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_710() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Desdemona.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_710() { - assert_eq!( - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - -0.0029670597283903604f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Desdemona.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_710() { - assert_eq!( - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0.0027925268031909274f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Desdemona.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_710() { - assert_eq!( - ( - 1.6594590527962085f64, - -13.265430289266899f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - -0.0006981317007977319f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Desdemona.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_711() { - assert_eq!(Juliet.id(), NaifId(711i32)); - assert_eq!(Juliet.name(), "Juliet"); - assert_eq!(format!("{}", Juliet), "Juliet"); - } - #[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); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_711() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Juliet.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_711() { - assert_eq!( - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0010471975511965976f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Juliet.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_711() { - assert_eq!( - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0010471975511965976f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Juliet.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_711() { - assert_eq!( - ( - 5.2806681848340435f64, - -12.74309158902866f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.00034906585039886593f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Juliet.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_712() { - assert_eq!(Portia.id(), NaifId(712i32)); - assert_eq!(Portia.name(), "Portia"); - assert_eq!(format!("{}", Portia), "Portia"); - } - #[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!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Portia.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_712() { - assert_eq!( - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0015707963267948964f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Portia.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_712() { - assert_eq!( - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0015707963267948964f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Portia.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_712() { - assert_eq!( - ( - 0.4368559117741807f64, - -12.243250601727652f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.00034906585039886593f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Portia.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_713() { - assert_eq!(Rosalind.id(), NaifId(713i32)); - assert_eq!(Rosalind.name(), "Rosalind"); - assert_eq!(format!("{}", Rosalind), "Rosalind"); - } - #[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); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_713() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Rosalind.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_713() { - assert_eq!( - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.005061454830783556f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Rosalind.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_713() { - assert_eq!( - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.004886921905584123f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Rosalind.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_713() { - assert_eq!( - ( - 5.496041814530144f64, - -11.250935609538423f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0013962634015954637f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Rosalind.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_714() { - assert_eq!(Belinda.id(), NaifId(714i32)); - assert_eq!(Belinda.name(), "Belinda"); - assert_eq!(format!("{}", Belinda), "Belinda"); - } - #[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); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_714() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Belinda.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_714() { - assert_eq!( - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0005235987755982988f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Belinda.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_714() { - assert_eq!( - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0005235987755982988f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Belinda.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_714() { - assert_eq!( - ( - 5.191656392982332f64, - -10.076882135239488f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.00017453292519943296f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Belinda.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_715() { - assert_eq!(Puck.id(), NaifId(715i32)); - assert_eq!(Puck.name(), "Puck"); - assert_eq!(format!("{}", Puck), "Puck"); - } - #[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!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Puck.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_715() { - assert_eq!( - ( - 4.49090669830661f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.005759586531581287f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Puck.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_715() { - assert_eq!( - ( - -0.2649409804527392f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0054105206811824215f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Puck.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_715() { - assert_eq!( - ( - 1.5924384095196262f64, - -8.247467318113788f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0015707963267948964f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Puck.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_716() { - assert_eq!(Caliban.id(), NaifId(716i32)); - assert_eq!(Caliban.name(), "Caliban"); - assert_eq!(format!("{}", Caliban), "Caliban"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_716() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Caliban.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_716() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Caliban.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_716() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Caliban.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_716() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Caliban.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_717() { - assert_eq!(Sycorax.id(), NaifId(717i32)); - assert_eq!(Sycorax.name(), "Sycorax"); - assert_eq!(format!("{}", Sycorax), "Sycorax"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_717() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Sycorax.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_717() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Sycorax.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_717() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Sycorax.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_717() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Sycorax.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_718() { - assert_eq!(Prospero.id(), NaifId(718i32)); - assert_eq!(Prospero.name(), "Prospero"); - assert_eq!(format!("{}", Prospero), "Prospero"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_718() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Prospero.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_718() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Prospero.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_718() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Prospero.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_718() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Prospero.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_719() { - assert_eq!(Setebos.id(), NaifId(719i32)); - assert_eq!(Setebos.name(), "Setebos"); - assert_eq!(format!("{}", Setebos), "Setebos"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_719() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Setebos.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_719() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Setebos.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_719() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Setebos.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_719() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Setebos.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_720() { - assert_eq!(Stephano.id(), NaifId(720i32)); - assert_eq!(Stephano.name(), "Stephano"); - assert_eq!(format!("{}", Stephano), "Stephano"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_720() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Stephano.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_720() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Stephano.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_720() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Stephano.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_720() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Stephano.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_721() { - assert_eq!(Trinculo.id(), NaifId(721i32)); - assert_eq!(Trinculo.name(), "Trinculo"); - assert_eq!(format!("{}", Trinculo), "Trinculo"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_721() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Trinculo.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_721() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Trinculo.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_721() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Trinculo.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_721() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Trinculo.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_722() { - assert_eq!(Francisco.id(), NaifId(722i32)); - assert_eq!(Francisco.name(), "Francisco"); - assert_eq!(format!("{}", Francisco), "Francisco"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_722() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Francisco.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_722() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Francisco.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_722() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Francisco.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_722() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Francisco.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_723() { - assert_eq!(Margaret.id(), NaifId(723i32)); - assert_eq!(Margaret.name(), "Margaret"); - assert_eq!(format!("{}", Margaret), "Margaret"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_723() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Margaret.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_723() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Margaret.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_723() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Margaret.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_723() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Margaret.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_724() { - assert_eq!(Ferdinand.id(), NaifId(724i32)); - assert_eq!(Ferdinand.name(), "Ferdinand"); - assert_eq!(format!("{}", Ferdinand), "Ferdinand"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_724() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Ferdinand.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_724() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Ferdinand.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_724() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Ferdinand.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_724() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Ferdinand.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_725() { - assert_eq!(Perdita.id(), NaifId(725i32)); - assert_eq!(Perdita.name(), "Perdita"); - assert_eq!(format!("{}", Perdita), "Perdita"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_725() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Perdita.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_725() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Perdita.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_725() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Perdita.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_725() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Perdita.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_726() { - assert_eq!(Mab.id(), NaifId(726i32)); - assert_eq!(Mab.name(), "Mab"); - assert_eq!(format!("{}", Mab), "Mab"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_726() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Mab.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_726() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Mab.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_726() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Mab.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_726() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Mab.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_727() { - assert_eq!(Cupid.id(), NaifId(727i32)); - assert_eq!(Cupid.name(), "Cupid"); - assert_eq!(format!("{}", Cupid), "Cupid"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_727() { - assert_eq!( - ( - &[ - 2.0202186091834364f64, - 2.4729570171507653f64, - 2.356718088967943f64, - 1.0780898789568973f64, - 4.351454891072263f64, - 0.7655014099247129f64, - 1.3554226970987964f64, - 2.746450110938277f64, - 1.776919711455427f64, - 2.419724474964938f64, - 1.784250094313803f64, - 5.522396286235258f64, - 5.3059754589879615f64, - 5.388005933831694f64, - 5.948431156647074f64, - 4.522846223618106f64, - 3.568500188627606f64, - 11.044792572470516f64 - ] as &[f64], - &[ - 959.7891933286942f64, - 731.077582955928f64, - 522.3307938967249f64, - 449.1358738582876f64, - 427.10754977009157f64, - 388.83160660922994f64, - 354.1171823199879f64, - 290.6454915444109f64, - 224.66977689099764f64, - 140.70512817020406f64, - -35.32930378471962f64, - 49.9855316454168f64, - -0.9065240134858548f64, - -1.626123264083117f64, - -1.314581992602129f64, - -8.810596596992575f64, - -70.65860756943924f64, - 99.9710632908336f64 - ] as &[f64] - ), - Cupid.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_727() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Cupid.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_727() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Cupid.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_727() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Cupid.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_801() { - assert_eq!(Triton.id(), NaifId(801i32)); - assert_eq!(Triton.name(), "Triton"); - assert_eq!(format!("{}", Triton), "Triton"); - } - #[test] - fn test_tri_axial_801() { - assert_eq!(Triton.polar_radius(), 1352.6f64); - assert_eq!(Triton.mean_radius(), 1352.6f64); - assert_eq!(Triton.subplanetary_radius(), 1352.6f64); - assert_eq!(Triton.along_orbit_radius(), 1352.6f64); - } - #[test] - fn test_point_mass_801() { - assert_eq!(Triton.gravitational_parameter(), 1428.495462910464f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_801() { - assert_eq!( - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64 - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64 - ] as &[f64] - ), - Triton.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_801() { - assert_eq!( - ( - 5.224817648770225f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.5646140130201657f64, - 0f64, - -0.1096066770252439f64, - -0.03630284844148206f64, - -0.012915436464758038f64, - -0.004886921905584123f64, - -0.0019198621771937625f64, - -0.0012217304763960308f64, - -0.00034906585039886593f64, - -0.00017453292519943296f64 - ] as &[f64] - ), - Triton.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_801() { - assert_eq!( - ( - 0.7185520530460655f64, - 0f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.3935717463247213f64, - 0f64, - 0.03665191429188092f64, - 0.009599310885968814f64, - 0.0027925268031909274f64, - 0.0008726646259971648f64, - 0.00034906585039886593f64, - 0.00017453292519943296f64, - 0f64, - 0f64 - ] as &[f64] - ), - Triton.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_801() { - assert_eq!( - ( - 5.175424830938785f64, - -1.069140942327404f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.3883357585687383f64, - 0f64, - 0.11746065865921838f64, - 0.03577924966588375f64, - 0.012915436464758038f64, - 0.004886921905584123f64, - 0.0019198621771937625f64, - 0.0008726646259971648f64, - 0.00034906585039886593f64, - 0.00017453292519943296f64 - ] as &[f64] - ), - Triton.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_802() { - assert_eq!(Nereid.id(), NaifId(802i32)); - assert_eq!(Nereid.name(), "Nereid"); - assert_eq!(format!("{}", Nereid), "Nereid"); - } - #[test] - fn test_tri_axial_802() { - assert_eq!(Nereid.polar_radius(), 170f64); - assert_eq!(Nereid.mean_radius(), 170f64); - assert_eq!(Nereid.subplanetary_radius(), 170f64); - assert_eq!(Nereid.along_orbit_radius(), 170f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_802() { - assert_eq!( - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64 - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64 - ] 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_body_803() { - assert_eq!(Naiad.id(), NaifId(803i32)); - assert_eq!(Naiad.name(), "Naiad"); - assert_eq!(format!("{}", Naiad), "Naiad"); - } - #[test] - fn test_tri_axial_803() { - assert_eq!(Naiad.polar_radius(), 29f64); - assert_eq!(Naiad.mean_radius(), 29f64); - assert_eq!(Naiad.subplanetary_radius(), 29f64); - assert_eq!(Naiad.along_orbit_radius(), 29f64); - } - #[test] - fn test_point_mass_803() { - assert_eq!(Naiad.gravitational_parameter(), 0.008530281246540886f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_803() { - assert_eq!( - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64 - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64 - ] as &[f64] - ), - Naiad.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_803() { - assert_eq!( - ( - 5.224817648770225f64, - 0f64, - 0f64, - &[ - 0.012217304763960306f64, - -0.11327186845443199f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.004363323129985824f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Naiad.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_803() { - assert_eq!( - ( - 0.7567747636647413f64, - 0f64, - 0f64, - &[ - -0.00890117918517108f64, - -0.08290313946973066f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0015707963267948964f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Naiad.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_803() { - assert_eq!( - ( - 4.434183497616794f64, - 21.342656148360604f64, - 0f64, - &[ - -0.008377580409572781f64, - 0.07679448708775051f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.00471238898038469f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Naiad.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_804() { - assert_eq!(Thalassa.id(), NaifId(804i32)); - assert_eq!(Thalassa.name(), "Thalassa"); - assert_eq!(format!("{}", Thalassa), "Thalassa"); - } - #[test] - fn test_tri_axial_804() { - assert_eq!(Thalassa.polar_radius(), 40f64); - assert_eq!(Thalassa.mean_radius(), 40f64); - assert_eq!(Thalassa.subplanetary_radius(), 40f64); - assert_eq!(Thalassa.along_orbit_radius(), 40f64); - } - #[test] - fn test_point_mass_804() { - assert_eq!(Thalassa.gravitational_parameter(), 0.0235887319799217f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_804() { - assert_eq!( - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64 - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64 - ] as &[f64] - ), - Thalassa.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_804() { - assert_eq!( - ( - 5.224817648770225f64, - 0f64, - 0f64, - &[ - 0.012217304763960306f64, - 0f64, - -0.004886921905584123f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Thalassa.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_804() { - assert_eq!( - ( - 0.7583455599915362f64, - 0f64, - 0f64, - &[ - -0.00890117918517108f64, - 0f64, - -0.003665191429188092f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Thalassa.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_804() { - assert_eq!( - ( - 1.7812830345854127f64, - 20.171739891174827f64, - 0f64, - &[ - -0.008377580409572781f64, - 0f64, - 0.0033161255787892262f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Thalassa.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_805() { - assert_eq!(Despina.id(), NaifId(805i32)); - assert_eq!(Despina.name(), "Despina"); - assert_eq!(format!("{}", Despina), "Despina"); - } - #[test] - fn test_tri_axial_805() { - assert_eq!(Despina.polar_radius(), 74f64); - assert_eq!(Despina.mean_radius(), 74f64); - assert_eq!(Despina.subplanetary_radius(), 74f64); - assert_eq!(Despina.along_orbit_radius(), 74f64); - } - #[test] - fn test_point_mass_805() { - assert_eq!(Despina.gravitational_parameter(), 0.1167318403814998f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_805() { - assert_eq!( - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64 - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64 - ] as &[f64] - ), - Despina.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_805() { - assert_eq!( - ( - 5.224817648770225f64, - 0f64, - 0f64, - &[ - 0.012217304763960306f64, - 0f64, - 0f64, - -0.0015707963267948964f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Despina.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_805() { - assert_eq!( - ( - 0.7583455599915362f64, - 0f64, - 0f64, - &[ - -0.00890117918517108f64, - 0f64, - 0f64, - -0.0012217304763960308f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Despina.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_805() { - assert_eq!( - ( - 5.34960869028782f64, - 18.77510290185297f64, - 0f64, - &[ - -0.008552113334772215f64, - 0f64, - 0f64, - 0.0010471975511965976f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Despina.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_806() { - assert_eq!(Galatea.id(), NaifId(806i32)); - assert_eq!(Galatea.name(), "Galatea"); - assert_eq!(format!("{}", Galatea), "Galatea"); - } - #[test] - fn test_tri_axial_806() { - assert_eq!(Galatea.polar_radius(), 79f64); - assert_eq!(Galatea.mean_radius(), 79f64); - assert_eq!(Galatea.subplanetary_radius(), 79f64); - assert_eq!(Galatea.along_orbit_radius(), 79f64); - } - #[test] - fn test_point_mass_806() { - assert_eq!(Galatea.gravitational_parameter(), 0.189898503906069f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_806() { - assert_eq!( - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64 - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64 - ] as &[f64] - ), - Galatea.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_806() { - assert_eq!( - ( - 5.224817648770225f64, - 0f64, - 0f64, - &[ - 0.012217304763960306f64, - 0f64, - 0f64, - 0f64, - -0.0012217304763960308f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Galatea.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_806() { - assert_eq!( - ( - 0.7579964941411373f64, - 0f64, - 0f64, - &[ - -0.00890117918517108f64, - 0f64, - 0f64, - 0f64, - -0.0008726646259971648f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Galatea.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_806() { - assert_eq!( - ( - 4.504520266472165f64, - 14.6548275586037f64, - 0f64, - &[ - -0.008377580409572781f64, - 0f64, - 0f64, - 0f64, - 0.0008726646259971648f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Galatea.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_807() { - assert_eq!(Larissa.id(), NaifId(807i32)); - assert_eq!(Larissa.name(), "Larissa"); - assert_eq!(format!("{}", Larissa), "Larissa"); - } - #[test] - fn test_tri_axial_807() { - assert_eq!(Larissa.polar_radius(), 96f64); - assert_eq!(Larissa.mean_radius(), 96f64); - assert_eq!(Larissa.subplanetary_radius(), 96f64); - assert_eq!(Larissa.along_orbit_radius(), 96f64); - } - #[test] - fn test_point_mass_807() { - assert_eq!(Larissa.gravitational_parameter(), 0.2548437405693583f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_807() { - assert_eq!( - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64 - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64 - ] as &[f64] - ), - Larissa.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_807() { - assert_eq!( - ( - 5.224817648770225f64, - 0f64, - 0f64, - &[ - 0.012217304763960306f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.00471238898038469f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Larissa.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_807() { - assert_eq!( - ( - 0.7576474282907384f64, - 0f64, - 0f64, - &[ - -0.00890117918517108f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.003490658503988659f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Larissa.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_807() { - assert_eq!( - ( - 3.1312952110030268f64, - 11.328119671568512f64, - 0f64, - &[ - -0.008377580409572781f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0033161255787892262f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Larissa.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_808() { - assert_eq!(Proteus.id(), NaifId(808i32)); - assert_eq!(Proteus.name(), "Proteus"); - assert_eq!(format!("{}", Proteus), "Proteus"); - } - #[test] - fn test_tri_axial_808() { - assert_eq!(Proteus.polar_radius(), 201f64); - assert_eq!(Proteus.mean_radius(), 209f64); - assert_eq!(Proteus.subplanetary_radius(), 218f64); - assert_eq!(Proteus.along_orbit_radius(), 208f64); - } - #[test] - fn test_point_mass_808() { - assert_eq!(Proteus.gravitational_parameter(), 2.583422379120727f64); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_808() { - assert_eq!( - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64 - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64 - ] as &[f64] - ), - Proteus.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_808() { - assert_eq!( - ( - 5.22324685244343f64, - 0f64, - 0f64, - &[ - 0.012217304763960306f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0008726646259971648f64, - 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!( - ( - 0.7489207820307667f64, - 0f64, - 0f64, - &[ - -0.00890117918517108f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - -0.0006981317007977319f64, - 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!( - ( - 1.6297884555123048f64, - 5.598412754411688f64, - 0f64, - &[ - -0.008377580409572781f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0006981317007977319f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64 - ] as &[f64] - ), - Proteus.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_809() { - assert_eq!(Halimede.id(), NaifId(809i32)); - assert_eq!(Halimede.name(), "Halimede"); - assert_eq!(format!("{}", Halimede), "Halimede"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_809() { - assert_eq!( - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64 - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64 - ] as &[f64] - ), - Halimede.nutation_precession_coefficients() - ) - } - #[test] - fn test_rotational_elements_right_ascension_coefficients_809() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Halimede.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_809() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Halimede.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_809() { - assert_eq!( - (0f64, 0f64, 0f64, &[] as &[f64]), - Halimede.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_810() { - assert_eq!(Psamathe.id(), NaifId(810i32)); - assert_eq!(Psamathe.name(), "Psamathe"); - assert_eq!(format!("{}", Psamathe), "Psamathe"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_810() { - assert_eq!( - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64 - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64 - ] 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_body_811() { - assert_eq!(Sao.id(), NaifId(811i32)); - assert_eq!(Sao.name(), "Sao"); - assert_eq!(format!("{}", Sao), "Sao"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_811() { - assert_eq!( - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64 - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64 - ] 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_body_812() { - assert_eq!(Laomedeia.id(), NaifId(812i32)); - assert_eq!(Laomedeia.name(), "Laomedeia"); - assert_eq!(format!("{}", Laomedeia), "Laomedeia"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_812() { - assert_eq!( - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64 - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64 - ] 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_body_813() { - assert_eq!(Neso.id(), NaifId(813i32)); - assert_eq!(Neso.name(), "Neso"); - assert_eq!(format!("{}", Neso), "Neso"); - } - #[test] - fn test_rotational_elements_nutation_precession_coefficients_813() { - assert_eq!( - ( - &[ - 6.245660728261709f64, - 5.653470513060032f64, - 3.848625533572696f64, - 6.183177941040311f64, - 1.3144074596769295f64, - 0.6171484235051949f64, - 2.4890140462691135f64, - 3.104068074671915f64, - 11.306941026120064f64, - 6.20813614934383f64, - 9.312204224015744f64, - 12.41627229868766f64, - 15.520340373359575f64, - 18.624408448031488f64, - 21.728476522703406f64, - 24.83254459737532f64, - 27.936612672047236f64 - ] as &[f64], - &[ - 0.9130864514733535f64, - 1092.6913034790819f64, - 961.0515899766616f64, - 812.7038395448996f64, - 455.6949957202075f64, - 250.02539666519567f64, - 49.29857005183183f64, - 0.9130864514733535f64, - 2185.3826069581637f64, - 1.826172902946707f64, - 2.7392593544200605f64, - 3.652345805893414f64, - 4.565432257366767f64, - 5.478518708840121f64, - 6.391605160313474f64, - 7.304691611786828f64, - 8.21777806326018f64 - ] 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_body_901() { - assert_eq!(Charon.id(), NaifId(901i32)); - assert_eq!(Charon.name(), "Charon"); - assert_eq!(format!("{}", Charon), "Charon"); - } - #[test] - fn test_tri_axial_901() { - assert_eq!(Charon.polar_radius(), 606f64); - assert_eq!(Charon.mean_radius(), 606f64); - assert_eq!(Charon.subplanetary_radius(), 606f64); - assert_eq!(Charon.along_orbit_radius(), 606f64); - } - #[test] - fn test_point_mass_901() { - assert_eq!(Charon.gravitational_parameter(), 105.8799888601881f64); - } - #[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!( - (2.3211657321048187f64, 0f64, 0f64, &[] as &[f64]), - Charon.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_901() { - assert_eq!( - (-0.10756464180041053f64, 0f64, 0f64, &[] as &[f64]), - Charon.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_901() { - assert_eq!( - ( - 2.1414317257344426f64, - 0.9837115923543857f64, - 0f64, - &[] as &[f64] - ), - Charon.prime_meridian_coefficients() - ) - } - #[test] - fn test_body_902() { - assert_eq!(Nix.id(), NaifId(902i32)); - assert_eq!(Nix.name(), "Nix"); - assert_eq!(format!("{}", Nix), "Nix"); - } - #[test] - fn test_point_mass_902() { - 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_body_903() { - assert_eq!(Hydra.id(), NaifId(903i32)); - assert_eq!(Hydra.name(), "Hydra"); - assert_eq!(format!("{}", Hydra), "Hydra"); - } - #[test] - fn test_point_mass_903() { - 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_body_904() { - assert_eq!(Kerberos.id(), NaifId(904i32)); - assert_eq!(Kerberos.name(), "Kerberos"); - assert_eq!(format!("{}", Kerberos), "Kerberos"); - } - #[test] - fn test_point_mass_904() { - 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_body_905() { - assert_eq!(Styx.id(), NaifId(905i32)); - assert_eq!(Styx.name(), "Styx"); - assert_eq!(format!("{}", Styx), "Styx"); - } - #[test] - 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-bodies/src/generated/sun.rs b/crates/lox-bodies/src/generated/sun.rs deleted file mode 100644 index 1765f5da..00000000 --- a/crates/lox-bodies/src/generated/sun.rs +++ /dev/null @@ -1,122 +0,0 @@ -/* - * 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, NaifId, NutationPrecessionCoefficients, PointMass, PolynomialCoefficients, - RotationalElements, Spheroid, -}; -use std::fmt::{Display, Formatter}; -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -pub struct Sun; -impl Body for Sun { - fn id(&self) -> NaifId { - NaifId(10i32) - } - fn name(&self) -> &'static str { - "Sun" - } -} -impl Display for Sun { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} -impl Ellipsoid for Sun { - fn polar_radius(&self) -> f64 { - 695700f64 - } - fn mean_radius(&self) -> f64 { - 695700f64 - } -} -impl Spheroid for Sun { - fn equatorial_radius(&self) -> f64 { - 695700f64 - } -} -impl PointMass for Sun { - fn gravitational_parameter(&self) -> f64 { - 132712440041.27942f64 - } -} -#[allow(clippy::approx_constant)] -impl RotationalElements for Sun { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - (&[] as &[f64], &[] as &[f64]) - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - (4.993910588731375f64, 0f64, 0f64, &[] as &[f64]) - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - (1.1147417932487782f64, 0f64, 0f64, &[] as &[f64]) - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 1.4691483511587469f64, - 0.24756448241988369f64, - 0f64, - &[] as &[f64], - ) - } -} -#[cfg(test)] -#[allow(clippy::approx_constant)] -mod tests { - use super::*; - #[test] - fn test_body_10() { - assert_eq!(Sun.id(), NaifId(10i32)); - assert_eq!(Sun.name(), "Sun"); - assert_eq!(format!("{}", Sun), "Sun"); - } - #[test] - fn test_spheroid_10() { - assert_eq!(Sun.polar_radius(), 695700f64); - assert_eq!(Sun.mean_radius(), 695700f64); - assert_eq!(Sun.equatorial_radius(), 695700f64); - } - #[test] - fn test_point_mass_10() { - assert_eq!(Sun.gravitational_parameter(), 132712440041.27942f64); - } - #[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!( - (4.993910588731375f64, 0f64, 0f64, &[] as &[f64]), - Sun.right_ascension_coefficients() - ) - } - #[test] - fn test_rotational_elements_declination_coefficients_10() { - assert_eq!( - (1.1147417932487782f64, 0f64, 0f64, &[] as &[f64]), - Sun.declination_coefficients() - ) - } - #[test] - fn test_rotational_elements_prime_meridian_coefficients_10() { - assert_eq!( - ( - 1.4691483511587469f64, - 0.24756448241988369f64, - 0f64, - &[] as &[f64] - ), - Sun.prime_meridian_coefficients() - ) - } -} diff --git a/crates/lox-bodies/src/lib.rs b/crates/lox-bodies/src/lib.rs index bfea1630..e305c7ab 100644 --- a/crates/lox-bodies/src/lib.rs +++ b/crates/lox-bodies/src/lib.rs @@ -6,20 +6,15 @@ * file, you can obtain one at https://mozilla.org/MPL/2.0/. */ -use std::f64::consts::PI; -use std::fmt::{Display, Formatter}; - -use dyn_clone::{clone_trait_object, DynClone}; - -pub use generated::barycenters::*; -pub use generated::minor::*; -pub use generated::planets::*; -pub use generated::satellites::*; -pub use generated::sun::*; +pub use crate::dynamic::DynOrigin; +pub use generated::*; use lox_math::constants::f64::time::{SECONDS_PER_DAY, SECONDS_PER_JULIAN_CENTURY}; +use std::fmt::{Display, Formatter}; +use thiserror::Error; -pub mod errors; +pub mod dynamic; pub mod fundamental; +#[allow(clippy::approx_constant)] mod generated; #[cfg(feature = "python")] pub mod python; @@ -34,401 +29,304 @@ impl Display for NaifId { } } -/// NaifId is implemented for all bodies. -pub trait Body { +/// `Origin` is implemented for all bodies and barycenters. +pub trait Origin { fn id(&self) -> NaifId; fn name(&self) -> &'static str; } -impl NaifId { - pub fn body(&self) -> Option> { - match self.0 { - 10 => Some(Box::new(Sun)), - - // Planets. - 199 => Some(Box::new(Mercury)), - 299 => Some(Box::new(Venus)), - 399 => Some(Box::new(Earth)), - 499 => Some(Box::new(Mars)), - 599 => Some(Box::new(Jupiter)), - 699 => Some(Box::new(Saturn)), - 799 => Some(Box::new(Uranus)), - 899 => Some(Box::new(Neptune)), - 999 => Some(Box::new(Pluto)), - - // Barycenters. - 0 => Some(Box::new(SolarSystemBarycenter)), - 1 => Some(Box::new(MercuryBarycenter)), - 2 => Some(Box::new(VenusBarycenter)), - 3 => Some(Box::new(EarthBarycenter)), - 4 => Some(Box::new(MarsBarycenter)), - 5 => Some(Box::new(JupiterBarycenter)), - 6 => Some(Box::new(SaturnBarycenter)), - 7 => Some(Box::new(UranusBarycenter)), - 8 => Some(Box::new(NeptuneBarycenter)), - 9 => Some(Box::new(PlutoBarycenter)), - - // Satellites. - 301 => Some(Box::new(Moon)), - 401 => Some(Box::new(Phobos)), - 402 => Some(Box::new(Deimos)), - 501 => Some(Box::new(Io)), - 502 => Some(Box::new(Europa)), - 503 => Some(Box::new(Ganymede)), - 504 => Some(Box::new(Callisto)), - 505 => Some(Box::new(Amalthea)), - 506 => Some(Box::new(Himalia)), - 507 => Some(Box::new(Elara)), - 508 => Some(Box::new(Pasiphae)), - 509 => Some(Box::new(Sinope)), - 510 => Some(Box::new(Lysithea)), - 511 => Some(Box::new(Carme)), - 512 => Some(Box::new(Ananke)), - 513 => Some(Box::new(Leda)), - 514 => Some(Box::new(Thebe)), - 515 => Some(Box::new(Adrastea)), - 516 => Some(Box::new(Metis)), - 517 => Some(Box::new(Callirrhoe)), - 518 => Some(Box::new(Themisto)), - 519 => Some(Box::new(Magaclite)), - 520 => Some(Box::new(Taygete)), - 521 => Some(Box::new(Chaldene)), - 522 => Some(Box::new(Harpalyke)), - 523 => Some(Box::new(Kalyke)), - 524 => Some(Box::new(Iocaste)), - 525 => Some(Box::new(Erinome)), - 526 => Some(Box::new(Isonoe)), - 527 => Some(Box::new(Praxidike)), - 528 => Some(Box::new(Autonoe)), - 529 => Some(Box::new(Thyone)), - 530 => Some(Box::new(Hermippe)), - 531 => Some(Box::new(Aitne)), - 532 => Some(Box::new(Eurydome)), - 533 => Some(Box::new(Euanthe)), - 534 => Some(Box::new(Euporie)), - 535 => Some(Box::new(Orthosie)), - 536 => Some(Box::new(Sponde)), - 537 => Some(Box::new(Kale)), - 538 => Some(Box::new(Pasithee)), - 539 => Some(Box::new(Hegemone)), - 540 => Some(Box::new(Mneme)), - 541 => Some(Box::new(Aoede)), - 542 => Some(Box::new(Thelxinoe)), - 543 => Some(Box::new(Arche)), - 544 => Some(Box::new(Kallichore)), - 545 => Some(Box::new(Helike)), - 546 => Some(Box::new(Carpo)), - 547 => Some(Box::new(Eukelade)), - 548 => Some(Box::new(Cyllene)), - 549 => Some(Box::new(Kore)), - 550 => Some(Box::new(Herse)), - 553 => Some(Box::new(Dia)), - 601 => Some(Box::new(Mimas)), - 602 => Some(Box::new(Enceladus)), - 603 => Some(Box::new(Tethys)), - 604 => Some(Box::new(Dione)), - 605 => Some(Box::new(Rhea)), - 606 => Some(Box::new(Titan)), - 607 => Some(Box::new(Hyperion)), - 608 => Some(Box::new(Iapetus)), - 609 => Some(Box::new(Phoebe)), - 610 => Some(Box::new(Janus)), - 611 => Some(Box::new(Epimetheus)), - 612 => Some(Box::new(Helene)), - 613 => Some(Box::new(Telesto)), - 614 => Some(Box::new(Calypso)), - 615 => Some(Box::new(Atlas)), - 616 => Some(Box::new(Prometheus)), - 617 => Some(Box::new(Pandora)), - 618 => Some(Box::new(Pan)), - 619 => Some(Box::new(Ymir)), - 620 => Some(Box::new(Paaliaq)), - 621 => Some(Box::new(Tarvos)), - 622 => Some(Box::new(Ijiraq)), - 623 => Some(Box::new(Suttungr)), - 624 => Some(Box::new(Kiviuq)), - 625 => Some(Box::new(Mundilfari)), - 626 => Some(Box::new(Albiorix)), - 627 => Some(Box::new(Skathi)), - 628 => Some(Box::new(Erriapus)), - 629 => Some(Box::new(Siarnaq)), - 630 => Some(Box::new(Thrymr)), - 631 => Some(Box::new(Narvi)), - 632 => Some(Box::new(Methone)), - 633 => Some(Box::new(Pallene)), - 634 => Some(Box::new(Polydeuces)), - 635 => Some(Box::new(Daphnis)), - 636 => Some(Box::new(Aegir)), - 637 => Some(Box::new(Bebhionn)), - 638 => Some(Box::new(Bergelmir)), - 639 => Some(Box::new(Bestla)), - 640 => Some(Box::new(Farbauti)), - 641 => Some(Box::new(Fenrir)), - 642 => Some(Box::new(Fornjot)), - 643 => Some(Box::new(Hati)), - 644 => Some(Box::new(Hyrrokkin)), - 645 => Some(Box::new(Kari)), - 646 => Some(Box::new(Loge)), - 647 => Some(Box::new(Skoll)), - 648 => Some(Box::new(Surtur)), - 649 => Some(Box::new(Anthe)), - 650 => Some(Box::new(Jarnsaxa)), - 651 => Some(Box::new(Greip)), - 652 => Some(Box::new(Tarqeq)), - 653 => Some(Box::new(Aegaeon)), - 701 => Some(Box::new(Ariel)), - 702 => Some(Box::new(Umbriel)), - 703 => Some(Box::new(Titania)), - 704 => Some(Box::new(Oberon)), - 705 => Some(Box::new(Miranda)), - 706 => Some(Box::new(Cordelia)), - 707 => Some(Box::new(Ophelia)), - 708 => Some(Box::new(Bianca)), - 709 => Some(Box::new(Cressida)), - 710 => Some(Box::new(Desdemona)), - 711 => Some(Box::new(Juliet)), - 712 => Some(Box::new(Portia)), - 713 => Some(Box::new(Rosalind)), - 714 => Some(Box::new(Belinda)), - 715 => Some(Box::new(Puck)), - 716 => Some(Box::new(Caliban)), - 717 => Some(Box::new(Sycorax)), - 718 => Some(Box::new(Prospero)), - 719 => Some(Box::new(Setebos)), - 720 => Some(Box::new(Stephano)), - 721 => Some(Box::new(Trinculo)), - 722 => Some(Box::new(Francisco)), - 723 => Some(Box::new(Margaret)), - 724 => Some(Box::new(Ferdinand)), - 725 => Some(Box::new(Perdita)), - 726 => Some(Box::new(Mab)), - 727 => Some(Box::new(Cupid)), - 801 => Some(Box::new(Triton)), - 802 => Some(Box::new(Nereid)), - 803 => Some(Box::new(Naiad)), - 804 => Some(Box::new(Thalassa)), - 805 => Some(Box::new(Despina)), - 806 => Some(Box::new(Galatea)), - 807 => Some(Box::new(Larissa)), - 808 => Some(Box::new(Proteus)), - 809 => Some(Box::new(Halimede)), - 810 => Some(Box::new(Psamathe)), - 811 => Some(Box::new(Sao)), - 812 => Some(Box::new(Laomedeia)), - 813 => Some(Box::new(Neso)), - 901 => Some(Box::new(Charon)), - 902 => Some(Box::new(Nix)), - 903 => Some(Box::new(Hydra)), - 904 => Some(Box::new(Kerberos)), - 905 => Some(Box::new(Styx)), - - // Minor bodies. - 9511010 => Some(Box::new(Gaspra)), - 2431010 => Some(Box::new(Ida)), - 2431011 => Some(Box::new(Dactyl)), - 2000001 => Some(Box::new(Ceres)), - 2000002 => Some(Box::new(Pallas)), - 2000004 => Some(Box::new(Vesta)), - 2000016 => Some(Box::new(Psyche)), - 2000021 => Some(Box::new(Lutetia)), - 2000216 => Some(Box::new(Kleopatra)), - 2000433 => Some(Box::new(Eros)), - 2000511 => Some(Box::new(Davida)), - 2000253 => Some(Box::new(Mathilde)), - 2002867 => Some(Box::new(Steins)), - 2009969 => Some(Box::new(Braille)), - 2004015 => Some(Box::new(WilsonHarrington)), - 2004179 => Some(Box::new(Toutatis)), - 2025143 => Some(Box::new(Itokawa)), - 2101955 => Some(Box::new(Bennu)), - _ => None, - } - } +pub type Radii = (f64, f64, f64); - pub fn name(&self) -> String { - if let Some(body) = self.body() { - body.name().to_string() - } else { - format!("Body {}", self.0) - } +pub trait MaybeTriaxialEllipsoid: Origin { + fn maybe_radii(&self) -> Option; +} + +pub trait TriaxialEllipsoid: Origin { + fn radii(&self) -> Radii; +} + +impl MaybeTriaxialEllipsoid for T { + fn maybe_radii(&self) -> Option { + Some(self.radii()) } } -pub trait Ellipsoid: Body { - fn polar_radius(&self) -> f64; +fn flattening(equatorial_radius: f64, polar_radius: f64) -> f64 { + (equatorial_radius - polar_radius) / equatorial_radius +} + +pub trait MaybeSpheroid: MaybeTriaxialEllipsoid { + fn maybe_polar_radius(&self) -> Option { + self.maybe_radii().map(|radii| radii.0) + } - fn mean_radius(&self) -> f64; + fn maybe_equatorial_radius(&self) -> Option { + self.maybe_radii().map(|radii| radii.2) + } + + fn maybe_flattening(&self) -> Option { + self.maybe_radii().map(|radii| flattening(radii.0, radii.2)) + } } -pub trait Spheroid: Ellipsoid { - fn equatorial_radius(&self) -> f64; +pub trait Spheroid: TriaxialEllipsoid { + fn equatorial_radius(&self) -> f64 { + self.radii().0 + } + + fn polar_radius(&self) -> f64 { + self.radii().2 + } fn flattening(&self) -> f64 { - (self.equatorial_radius() - self.polar_radius()) / self.equatorial_radius() + flattening(self.equatorial_radius(), self.polar_radius()) } } -pub trait TriAxial: Ellipsoid { - fn subplanetary_radius(&self) -> f64; +impl MaybeSpheroid for T { + fn maybe_polar_radius(&self) -> Option { + Some(self.polar_radius()) + } - fn along_orbit_radius(&self) -> f64; -} + fn maybe_equatorial_radius(&self) -> Option { + Some(self.equatorial_radius()) + } -pub trait PointMass: Body { - fn gravitational_parameter(&self) -> f64; + fn maybe_flattening(&self) -> Option { + Some(self.flattening()) + } } -// Planets. -pub trait Planet: RotationalElements + PointMass + Spheroid + DynClone + std::fmt::Debug {} -clone_trait_object!(Planet); +pub trait MaybeMeanRadius: Origin { + fn maybe_mean_radius(&self) -> Option; +} -// Barycenters. -pub trait Barycenter: PointMass + DynClone + std::fmt::Debug {} -clone_trait_object!(Barycenter); +pub trait MeanRadius: Origin { + fn mean_radius(&self) -> f64; +} -impl PointMass for SolarSystemBarycenter { - fn gravitational_parameter(&self) -> f64 { - Sun.gravitational_parameter() +impl MaybeMeanRadius for T { + fn maybe_mean_radius(&self) -> Option { + Some(self.mean_radius()) } } -// Satellites. -pub trait Satellite: PointMass + TriAxial + DynClone + std::fmt::Debug {} -clone_trait_object!(Satellite); +pub trait PointMass: Origin { + fn gravitational_parameter(&self) -> f64; +} -// Minor bodies. -pub trait MinorBody: PointMass + TriAxial + DynClone + std::fmt::Debug {} -clone_trait_object!(MinorBody); +pub trait MaybePointMass: Origin { + fn maybe_gravitational_parameter(&self) -> Option; +} -pub type PolynomialCoefficients = (f64, f64, f64, &'static [f64]); +impl MaybePointMass for T { + fn maybe_gravitational_parameter(&self) -> Option { + Some(self.gravitational_parameter()) + } +} -pub type NutationPrecessionCoefficients = (&'static [f64], &'static [f64]); +#[derive(Clone, Copy, Debug)] +pub(crate) enum RotationalElementType { + RightAscension, + Declination, + Rotation, +} -type Elements = (f64, f64, f64); +impl RotationalElementType { + fn sincos(&self, val: f64) -> f64 { + match self { + RotationalElementType::Declination => val.cos(), + _ => val.sin(), + } + } -pub trait RotationalElements: Body { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients; - fn right_ascension_coefficients(&self) -> PolynomialCoefficients; - fn declination_coefficients(&self) -> PolynomialCoefficients; - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients; + fn sincos_dot(&self, val: f64) -> f64 { + match self { + RotationalElementType::Declination => val.sin(), + _ => val.cos(), + } + } - fn theta(&self, t: f64) -> Vec { - let t = t / SECONDS_PER_JULIAN_CENTURY; - let (theta0, theta1) = self.nutation_precession_coefficients(); - let mut theta = vec![0.0; theta0.len()]; - if theta0.is_empty() { - return theta; + fn sign(&self) -> f64 { + match self { + RotationalElementType::Declination => -1.0, + _ => 1.0, } + } - for i in 0..theta.len() { - theta[i] = theta0[i] + theta1[i] * t; + fn dt(&self) -> f64 { + match self { + RotationalElementType::Rotation => SECONDS_PER_DAY, + _ => SECONDS_PER_JULIAN_CENTURY, } - theta + } +} + +struct NutationPrecessionCoefficients { + theta0: [f64; N], + theta1: [f64; N], +} + +pub(crate) struct RotationalElement { + typ: RotationalElementType, + c0: f64, + c1: f64, + c2: f64, + c: Option<[f64; N]>, +} + +impl RotationalElement { + fn trig_term( + &self, + nut_prec: Option<&NutationPrecessionCoefficients>, + t: f64, + ) -> f64 { + let Some(nut_prec) = nut_prec else { return 0.0 }; + self.c + .map(|c| { + c.iter() + .zip(nut_prec.theta0.iter()) + .zip(nut_prec.theta1.iter()) + .map(|((&c, &theta0), &theta1)| { + c * self + .typ + .sincos(theta0 + theta1 * t / SECONDS_PER_JULIAN_CENTURY) + }) + .sum() + }) + .unwrap_or_default() } + fn trig_term_dot( + &self, + nut_prec: Option<&NutationPrecessionCoefficients>, + t: f64, + ) -> f64 { + let Some(nut_prec) = nut_prec else { return 0.0 }; + self.c + .map(|c| { + c.iter() + .zip(nut_prec.theta0.iter()) + .zip(nut_prec.theta1.iter()) + .map(|((&c, &theta0), &theta1)| { + c * theta1 / SECONDS_PER_JULIAN_CENTURY + * self + .typ + .sincos_dot(theta0 + theta1 * t / SECONDS_PER_JULIAN_CENTURY) + }) + .sum() + }) + .unwrap_or_default() + } + + fn angle( + &self, + nut_prec: Option<&NutationPrecessionCoefficients>, + t: f64, + ) -> f64 { + self.c0 + + self.c1 * t / self.typ.dt() + + self.c2 * t.powi(2) / self.typ.dt().powi(2) + + self.trig_term(nut_prec, t) + } + + fn angle_dot( + &self, + nut_prec: Option<&NutationPrecessionCoefficients>, + t: f64, + ) -> f64 { + self.c1 / self.typ.dt() + + 2.0 * self.c2 * t / self.typ.dt().powi(2) + + self.typ.sign() * self.trig_term_dot(nut_prec, t) + } +} + +pub type Elements = (f64, f64, f64); + +pub trait RotationalElements: Origin { + fn rotational_elements(&self, t: f64) -> Elements; + + fn rotational_element_rates(&self, t: f64) -> Elements; + fn right_ascension(&self, t: f64) -> f64 { - let dt = SECONDS_PER_JULIAN_CENTURY; - let (c0, c1, c2, c) = self.right_ascension_coefficients(); - let theta = self.theta(t); - let mut c_trig = vec![0.0; c.len()]; - if !c.is_empty() { - for i in 0..c.len() { - c_trig[i] = c[i] * theta[i].sin(); - } - } - let c_trig: f64 = c_trig.iter().sum(); - c0 + c1 * t / dt + c2 * t.powi(2) / dt.powi(2) + c_trig - } - - fn right_ascension_dot(&self, t: f64) -> f64 { - let dt = SECONDS_PER_JULIAN_CENTURY; - let (_, c1, c2, c) = self.right_ascension_coefficients(); - let (_, theta1) = self.nutation_precession_coefficients(); - let theta = self.theta(t); - let mut c_trig = vec![0.0; c.len()]; - if !c.is_empty() { - 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(); - c1 / dt + 2.0 * c2 * t / dt.powi(2) + c_trig + self.rotational_elements(t).0 + } + + fn right_ascension_rate(&self, t: f64) -> f64 { + self.rotational_element_rates(t).0 } fn declination(&self, t: f64) -> f64 { - let dt = SECONDS_PER_JULIAN_CENTURY; - let (c0, c1, c2, c) = self.declination_coefficients(); - let theta = self.theta(t); - let mut c_trig = vec![0.0; c.len()]; - if !c.is_empty() { - for i in 0..c.len() { - c_trig[i] = c[i] * theta[i].cos(); - } - } - let c_trig: f64 = c_trig.iter().sum(); - c0 + c1 * t / dt + c2 * t.powi(2) / dt.powi(2) + c_trig - } - - fn declination_dot(&self, t: f64) -> f64 { - let dt = SECONDS_PER_JULIAN_CENTURY; - let (_, c1, c2, c) = self.declination_coefficients(); - let (_, theta1) = self.nutation_precession_coefficients(); - let theta = self.theta(t); - let mut c_trig = vec![0.0; c.len()]; - if !c.is_empty() { - 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(); - c1 / dt + 2.0 * c2 * t / dt.powi(2) - c_trig - } - - fn prime_meridian(&self, t: f64) -> f64 { - let dt = SECONDS_PER_DAY; - let (c0, c1, c2, c) = self.prime_meridian_coefficients(); - let theta = self.theta(t); - let mut c_trig = vec![0.0; c.len()]; - if !c.is_empty() { - for i in 0..c.len() { - c_trig[i] = c[i] * theta[i].sin(); - } - } - let c_trig: f64 = c_trig.iter().sum(); - c0 + c1 * t / dt + c2 * t.powi(2) / dt.powi(2) + c_trig - } - - fn prime_meridian_dot(&self, t: f64) -> f64 { - let dt = SECONDS_PER_DAY; - let (_, c1, c2, c) = self.prime_meridian_coefficients(); - let (_, theta1) = self.nutation_precession_coefficients(); - let theta = self.theta(t); - let mut c_trig = vec![0.0; c.len()]; - if !c.is_empty() { - 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(); - c1 / dt + 2.0 * c2 * t / dt.powi(2) + c_trig + self.rotational_elements(t).1 + } + + fn declination_rate(&self, t: f64) -> f64 { + self.rotational_element_rates(t).1 } - fn rotational_elements(&self, t: f64) -> Elements { - ( - self.right_ascension(t) + PI / 2.0, - PI / 2.0 - self.declination(t), - self.prime_meridian(t) % (2.0 * PI), - ) + fn rotation_angle(&self, t: f64) -> f64 { + self.rotational_elements(t).2 } - fn rotational_element_rates(&self, t: f64) -> Elements { - ( - self.right_ascension_dot(t), - -self.declination_dot(t), - self.prime_meridian_dot(t), - ) + fn rotation_rate(&self, t: f64) -> f64 { + self.rotational_element_rates(t).2 } } + +#[derive(Clone, Debug, Error, Eq, PartialEq)] +#[error("no rotational elements defined for origin `{0}`")] +pub struct UndefinedRotationalElementsError(String); + +pub trait TryRotationalElements: Origin { + fn try_rotational_elements(&self, t: f64) + -> Result; + + fn try_rotational_element_rates( + &self, + t: f64, + ) -> Result; + + fn try_right_ascension(&self, t: f64) -> Result { + self.try_rotational_elements(t).map(|r| r.0) + } + + fn try_right_ascension_rate(&self, t: f64) -> Result { + self.try_rotational_element_rates(t).map(|r| r.0) + } + + fn try_declination(&self, t: f64) -> Result { + self.try_rotational_elements(t).map(|r| r.1) + } + + fn try_declination_rate(&self, t: f64) -> Result { + self.try_rotational_element_rates(t).map(|r| r.1) + } + + fn try_rotation_angle(&self, t: f64) -> Result { + self.try_rotational_elements(t).map(|r| r.2) + } + + fn try_rotation_rate(&self, t: f64) -> Result { + self.try_rotational_element_rates(t).map(|r| r.2) + } +} + +impl TryRotationalElements for T { + fn try_rotational_elements( + &self, + t: f64, + ) -> Result { + Ok(self.rotational_elements(t)) + } + + fn try_rotational_element_rates( + &self, + t: f64, + ) -> Result { + Ok(self.rotational_element_rates(t)) + } +} + #[cfg(test)] mod tests { use float_eq::assert_float_eq; @@ -441,7 +339,7 @@ mod tests { #[derive(Debug, Copy, Clone, Eq, PartialEq)] pub struct Jupiter; - impl Body for Jupiter { + impl Origin for Jupiter { fn id(&self) -> NaifId { NaifId(599) } @@ -453,7 +351,7 @@ mod tests { #[derive(Debug, Copy, Clone, Eq, PartialEq)] pub struct Rupert; - impl Body for Rupert { + impl Origin for Rupert { fn id(&self) -> NaifId { NaifId(1099) } @@ -478,116 +376,114 @@ mod tests { assert_eq!(name, "Persephone/Rupert"); } - #[test] - fn test_naif_id() { - let id = NaifId(0); - let name = id.name(); - assert_eq!(name, "Solar System Barycenter"); - - let id = NaifId(-42); - let name = id.name(); - assert_eq!(name, "Body -42"); - } + const NUTATION_PRECESSION_JUPITER: NutationPrecessionCoefficients<15> = + NutationPrecessionCoefficients { + theta0: [ + 1.2796754075622423f64, + 0.42970006184100396f64, + 4.9549897464119015f64, + 6.2098814785958245f64, + 2.092649773141201f64, + 4.010766621082969f64, + 6.147922290150026f64, + 1.9783307071355725f64, + 2.5593508151244846f64, + 0.8594001236820079f64, + 1.734171606432425f64, + 3.0699533280603655f64, + 5.241627996900319f64, + 1.9898901100379935f64, + 0.864134346731335f64, + ], + theta1: [ + 1596.503281347521f64, + 787.7927551311844f64, + 84.66068602648895f64, + 20.792107379008446f64, + 4.574507969477138f64, + 1.1222467090323538f64, + 41.58421475801689f64, + 105.9414855960558f64, + 3193.006562695042f64, + 1575.5855102623689f64, + 84.65553032387855f64, + 20.80363527871787f64, + 4.582318317879813f64, + 105.94580703128374f64, + 1.1222467090323538f64, + ], + }; + + const RIGHT_ASCENSION_JUPITER: RotationalElement<15> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: 4.6784701644349695f64, + c1: -0.00011342894808711148f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.0000020420352248333656f64, + 0.000016371188383706813f64, + 0.000024993114888558796f64, + 0.0000005235987755982989f64, + 0.00003752457891787809f64, + ]), + }; + + const DECLINATION_JUPITER: RotationalElement<15> = RotationalElement { + typ: RotationalElementType::Declination, + c0: 1.1256553894213766f64, + c1: 0.00004211479485062318f64, + c2: 0f64, + c: Some([ + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0f64, + 0.0000008726646259971648f64, + 0.000007051130178057092f64, + 0.000010768681484805013f64, + -0.00000022689280275926283f64, + 0.00001616174887346749f64, + ]), + }; + + const ROTATION_JUPITER: RotationalElement<15> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: 4.973315703557842f64, + c1: 15.193719457141356f64, + c2: 0f64, + c: None, + }; impl RotationalElements for Jupiter { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { + fn rotational_elements(&self, t: f64) -> Elements { ( - &[ - 1.2796754075622423f64, - 0.42970006184100396f64, - 4.9549897464119015f64, - 6.2098814785958245f64, - 2.092649773141201f64, - 4.010766621082969f64, - 6.147922290150026f64, - 1.9783307071355725f64, - 2.5593508151244846f64, - 0.8594001236820079f64, - 1.734171606432425f64, - 3.0699533280603655f64, - 5.241627996900319f64, - 1.9898901100379935f64, - 0.864134346731335f64, - ], - &[ - 1596.503281347521f64, - 787.7927551311844f64, - 84.66068602648895f64, - 20.792107379008446f64, - 4.574507969477138f64, - 1.1222467090323538f64, - 41.58421475801689f64, - 105.9414855960558f64, - 3193.006562695042f64, - 1575.5855102623689f64, - 84.65553032387855f64, - 20.80363527871787f64, - 4.582318317879813f64, - 105.94580703128374f64, - 1.1222467090323538f64, - ], + RIGHT_ASCENSION_JUPITER.angle(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_JUPITER.angle(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_JUPITER.angle(Some(&NUTATION_PRECESSION_JUPITER), t), ) } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { + fn rotational_element_rates(&self, t: f64) -> Elements { ( - 4.6784701644349695f64, - -0.00011342894808711148f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0000020420352248333656f64, - 0.000016371188383706813f64, - 0.000024993114888558796f64, - 0.0000005235987755982989f64, - 0.00003752457891787809f64, - ], - ) - } - - fn declination_coefficients(&self) -> PolynomialCoefficients { - ( - 1.1256553894213766f64, - 0.00004211479485062318f64, - 0f64, - &[ - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0f64, - 0.0000008726646259971648f64, - 0.000007051130178057092f64, - 0.000010768681484805013f64, - -0.00000022689280275926283f64, - 0.00001616174887346749f64, - ], - ) - } - - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - ( - 4.973315703557842f64, - 15.193719457141356f64, - 0f64, - &[ - 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, 0f64, - 0f64, 0f64, - ], + RIGHT_ASCENSION_JUPITER.angle_dot(Some(&NUTATION_PRECESSION_JUPITER), t), + DECLINATION_JUPITER.angle_dot(Some(&NUTATION_PRECESSION_JUPITER), t), + ROTATION_JUPITER.angle_dot(Some(&NUTATION_PRECESSION_JUPITER), t), ) } } @@ -600,7 +496,7 @@ mod tests { #[test] fn test_rotational_elements_right_ascension_dot() { assert_float_eq!( - Jupiter.right_ascension_dot(0.0), + Jupiter.right_ascension_rate(0.0), -1.3266588500099516e-13, rel <= 1e-8 ); @@ -614,7 +510,7 @@ mod tests { #[test] fn test_rotational_elements_declination_dot() { assert_float_eq!( - Jupiter.declination_dot(0.0), + Jupiter.declination_rate(0.0), 3.004482367136341e-15, rel <= 1e-8 ); @@ -622,82 +518,15 @@ mod tests { #[test] fn test_rotational_elements_prime_meridian() { - assert_float_eq!(Jupiter.prime_meridian(0.0), 4.973315703557842, rel <= 1e-8); + assert_float_eq!(Jupiter.rotation_angle(0.0), 4.973315703557842, rel <= 1e-8); } #[test] fn test_rotational_elements_prime_meridian_dot() { assert_float_eq!( - Jupiter.prime_meridian_dot(0.0), + Jupiter.rotation_rate(0.0), 0.00017585323445765458, rel <= 1e-8 ); } - - #[test] - fn test_rotational_elements_rotational_elements() { - let (ra, dec, pm) = Jupiter.rotational_elements(0.0); - let (expected_ra, expected_dec, expected_pm) = - (6.249277121030398, 0.44513208936761073, 4.973315703557842); - - assert_float_eq!( - ra, - expected_ra, - rel <= 1e-8, - "Expected right ascension {}, got {}", - expected_ra, - ra - ); - assert_float_eq!( - dec, - expected_dec, - rel <= 1e-8, - "Expected declination {}, got {}", - expected_dec, - dec - ); - assert_float_eq!( - pm, - expected_pm, - rel <= 1e-8, - "Expected prime meridian {}, got {}", - expected_pm, - pm - ); - } - - #[test] - fn test_rotational_elements_rotational_element_rates() { - let (ra_dot, dec_dot, pm_dot) = Jupiter.rotational_element_rates(0.0); - let (expected_ra_dot, expected_dec_dot, expected_pm_dot) = ( - -1.3266588500099516e-13, - -3.004482367136341e-15, - 0.00017585323445765458, - ); - - assert_float_eq!( - ra_dot, - expected_ra_dot, - rel <= 1e-8, - "Expected right ascension rate {}, got {}", - expected_ra_dot, - ra_dot - ); - assert_float_eq!( - dec_dot, - expected_dec_dot, - rel <= 1e-8, - "Expected declination rate {}, got {}", - expected_dec_dot, - dec_dot - ); - assert_float_eq!( - pm_dot, - expected_pm_dot, - rel <= 1e-8, - "Expected prime meridian rate {}, got {}", - expected_pm_dot, - pm_dot - ); - } } diff --git a/crates/lox-bodies/src/python.rs b/crates/lox-bodies/src/python.rs index fbf42366..1b5b2f8a 100644 --- a/crates/lox-bodies/src/python.rs +++ b/crates/lox-bodies/src/python.rs @@ -5,391 +5,52 @@ * 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/. */ - -use pyo3::exceptions::PyValueError; +use pyo3::exceptions::{PyTypeError, PyValueError}; use pyo3::prelude::*; -use pyo3::types::PyTuple; - -use crate::{ - Adrastea, Amalthea, Ariel, Atlas, Barycenter, Body, Callisto, Ceres, Charon, Davida, Deimos, - Despina, Dione, Earth, EarthBarycenter, Ellipsoid, Enceladus, Epimetheus, Eros, Europa, - Galatea, Ganymede, Helene, Himalia, Hyperion, Iapetus, Io, Janus, Jupiter, JupiterBarycenter, - Larissa, Mars, MarsBarycenter, Mercury, MercuryBarycenter, Metis, Mimas, MinorBody, Miranda, - Moon, Naiad, NaifId, Neptune, NeptuneBarycenter, NutationPrecessionCoefficients, Oberon, - Pandora, Phobos, Phoebe, Planet, Pluto, PlutoBarycenter, PointMass, PolynomialCoefficients, - Prometheus, Proteus, Psyche, Rhea, RotationalElements, Satellite, Saturn, SaturnBarycenter, - SolarSystemBarycenter, Spheroid, Sun, Tethys, Thalassa, Thebe, Titan, Titania, Triton, Umbriel, - Uranus, UranusBarycenter, Venus, VenusBarycenter, Vesta, -}; - -#[pyclass(name = "Sun", module = "lox_space", frozen)] -#[derive(Clone, Debug, Default)] -pub struct PySun; - -#[pymethods] -impl PySun { - #[new] - pub fn new() -> Self { - Self - } - - fn __repr__(&self) -> &str { - "Sun()" - } - - fn __str__(&self) -> &str { - "Sun" - } - - fn __eq__(&self, _other: &Self) -> bool { - true - } - - fn __getnewargs__(&self) -> Py { - // A unit return type would be converted to `None` on the Python side, - // but we actually want an empty tuple here. - Python::with_gil(|py| PyTuple::empty_bound(py).into_py(py)) - } - - pub fn id(&self) -> i32 { - Sun.id().0 - } - - pub fn name(&self) -> &'static str { - Sun.name() - } - - pub fn gravitational_parameter(&self) -> f64 { - Sun.gravitational_parameter() - } - - pub fn mean_radius(&self) -> f64 { - Sun.mean_radius() - } - - pub fn polar_radius(&self) -> f64 { - Sun.polar_radius() - } - - pub fn equatorial_radius(&self) -> f64 { - Sun.equatorial_radius() - } -} - -#[pyclass(name = "Barycenter", module = "lox_space", frozen)] -#[derive(Debug, Clone)] -pub struct PyBarycenter(Box); - -#[pymethods] -impl PyBarycenter { - #[new] - pub fn new(name: &str) -> PyResult { - let barycenter: Option> = match name { - "ssb" | "SSB" | "solar system barycenter" | "Solar System Barycenter" => { - Some(Box::new(SolarSystemBarycenter)) - } - "mercury barycenter" | "Mercury Barycenter" => Some(Box::new(MercuryBarycenter)), - "venus barycenter" | "Venus Barycenter" => Some(Box::new(VenusBarycenter)), - "earth barycenter" | "Earth Barycenter" => Some(Box::new(EarthBarycenter)), - "mars barycenter" | "Mars Barycenter" => Some(Box::new(MarsBarycenter)), - "jupiter barycenter" | "Jupiter Barycenter" => Some(Box::new(JupiterBarycenter)), - "saturn barycenter" | "Saturn Barycenter" => Some(Box::new(SaturnBarycenter)), - "uranus barycenter" | "Uranus Barycenter" => Some(Box::new(UranusBarycenter)), - "neptune barycenter" | "Neptune Barycenter" => Some(Box::new(NeptuneBarycenter)), - "pluto barycenter" | "Pluto Barycenter" => Some(Box::new(PlutoBarycenter)), - _ => None, - }; - match barycenter { - Some(barycenter) => Ok(Self(barycenter)), - None => Err(PyValueError::new_err(format!( - "unknown barycenter: {}", - name - ))), - } - } - - fn __repr__(&self) -> String { - format!("Barycenter(\"{}\")", self.name()) - } - - fn __str__(&self) -> &str { - self.name() - } - - fn __eq__(&self, other: &Self) -> bool { - self.id() == other.id() - } - - fn __getnewargs__(&self) -> (&str,) { - (self.name(),) - } - - pub fn id(&self) -> i32 { - self.0.id().0 - } - - pub fn name(&self) -> &'static str { - self.0.name() - } - - pub fn gravitational_parameter(&self) -> f64 { - self.0.gravitational_parameter() - } -} - -#[pyclass(name = "Planet", module = "lox_space", frozen)] -#[derive(Clone, Debug)] -pub struct PyPlanet(Box); - -#[pymethods] -impl PyPlanet { - #[new] - pub fn new(name: &str) -> PyResult { - let planet: Option> = match name { - "mercury" | "Mercury" => Some(Box::new(Mercury)), - "venus" | "Venus" => Some(Box::new(Venus)), - "earth" | "Earth" => Some(Box::new(Earth)), - "mars" | "Mars" => Some(Box::new(Mars)), - "jupiter" | "Jupiter" => Some(Box::new(Jupiter)), - "saturn" | "Saturn" => Some(Box::new(Saturn)), - "uranus" | "Uranus" => Some(Box::new(Uranus)), - "neptune" | "Neptune" => Some(Box::new(Neptune)), - "pluto" | "Pluto" => Some(Box::new(Pluto)), - _ => None, - }; - match planet { - Some(planet) => Ok(Self(planet)), - None => Err(PyValueError::new_err(format!("unknown planet: {}", name))), - } - } - - fn __repr__(&self) -> String { - format!("Planet(\"{}\")", self.name()) - } - - fn __str__(&self) -> &str { - self.name() - } - - fn __eq__(&self, other: &Self) -> bool { - self.id() == other.id() - } +use std::str::FromStr; - fn __getnewargs__(&self) -> (&str,) { - (self.name(),) - } +use crate::dynamic::{DynOrigin, UnknownOriginId, UnknownOriginName}; +use crate::Origin; - pub fn id(&self) -> i32 { - self.0.id().0 - } - - pub fn name(&self) -> &'static str { - self.0.name() - } - - pub fn gravitational_parameter(&self) -> f64 { - self.0.gravitational_parameter() - } - - pub fn mean_radius(&self) -> f64 { - self.0.mean_radius() - } - - pub fn polar_radius(&self) -> f64 { - self.0.polar_radius() - } - - pub fn equatorial_radius(&self) -> f64 { - self.0.equatorial_radius() +impl From for PyErr { + fn from(err: UnknownOriginId) -> Self { + PyValueError::new_err(err.to_string()) } } -impl Body for PyPlanet { - fn id(&self) -> NaifId { - self.0.id() - } - - fn name(&self) -> &'static str { - self.0.name() - } -} - -impl Ellipsoid for PyPlanet { - fn polar_radius(&self) -> f64 { - self.0.polar_radius() - } - - fn mean_radius(&self) -> f64 { - self.0.mean_radius() - } -} - -impl Spheroid for PyPlanet { - fn equatorial_radius(&self) -> f64 { - self.0.equatorial_radius() - } -} - -impl RotationalElements for PyPlanet { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - self.0.nutation_precession_coefficients() - } - - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - self.0.right_ascension_coefficients() - } - - fn declination_coefficients(&self) -> PolynomialCoefficients { - self.0.declination_coefficients() - } - - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - self.0.prime_meridian_coefficients() +impl From for PyErr { + fn from(err: UnknownOriginName) -> Self { + PyValueError::new_err(err.to_string()) } } -#[pyclass(name = "Satellite", module = "lox_space", frozen)] -#[derive(Clone, Debug)] -pub struct PySatellite(Box); +#[pyclass(name = "Origin", module = "lox_space", frozen, eq)] +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct PyOrigin(pub DynOrigin); #[pymethods] -impl PySatellite { +impl PyOrigin { #[new] - pub fn new(name: &str) -> PyResult { - let satellite: Option> = match name { - "moon" | "Moon" | "luna" | "Luna" => Some(Box::new(Moon)), - "phobos" | "Phobos" => Some(Box::new(Phobos)), - "deimos" | "Deimos" => Some(Box::new(Deimos)), - "io" | "Io" => Some(Box::new(Io)), - "europa" | "Europa" => Some(Box::new(Europa)), - "ganymede" | "Ganymede" => Some(Box::new(Ganymede)), - "callisto" | "Callisto" => Some(Box::new(Callisto)), - "amalthea" | "Amalthea" => Some(Box::new(Amalthea)), - "himalia" | "Himalia" => Some(Box::new(Himalia)), - "thebe" | "Thebe" => Some(Box::new(Thebe)), - "adrastea" | "Adrastea" => Some(Box::new(Adrastea)), - "metis" | "Metis" => Some(Box::new(Metis)), - "mimas" | "Mimas" => Some(Box::new(Mimas)), - "enceladus" | "Enceladus" => Some(Box::new(Enceladus)), - "tethys" | "Tethys" => Some(Box::new(Tethys)), - "dione" | "Dione" => Some(Box::new(Dione)), - "rhea" | "Rhea" => Some(Box::new(Rhea)), - "titan" | "Titan" => Some(Box::new(Titan)), - "hyperion" | "Hyperion" => Some(Box::new(Hyperion)), - "iapetus" | "Iapetus" => Some(Box::new(Iapetus)), - "phoebe" | "Phoebe" => Some(Box::new(Phoebe)), - "janus" | "Janus" => Some(Box::new(Janus)), - "epimetheus" | "Epimetheus" => Some(Box::new(Epimetheus)), - "helene" | "Helene" => Some(Box::new(Helene)), - "atlas" | "Atlas" => Some(Box::new(Atlas)), - "prometheus" | "Prometheus" => Some(Box::new(Prometheus)), - "pandora" | "Pandora" => Some(Box::new(Pandora)), - "ariel" | "Ariel" => Some(Box::new(Ariel)), - "umbriel" | "Umbriel" => Some(Box::new(Umbriel)), - "titania" | "Titania" => Some(Box::new(Titania)), - "oberon" | "Oberon" => Some(Box::new(Oberon)), - "miranda" | "Miranda" => Some(Box::new(Miranda)), - "triton" | "Triton" => Some(Box::new(Triton)), - "naiad" | "Naiad" => Some(Box::new(Naiad)), - "thalassa" | "Thalassa" => Some(Box::new(Thalassa)), - "despina" | "Despina" => Some(Box::new(Despina)), - "galatea" | "Galatea" => Some(Box::new(Galatea)), - "larissa" | "Larissa" => Some(Box::new(Larissa)), - "proteus" | "Proteus" => Some(Box::new(Proteus)), - "charon" | "Charon" => Some(Box::new(Charon)), - _ => None, - }; - match satellite { - Some(satellite) => Ok(Self(satellite)), - None => Err(PyValueError::new_err(format!( - "unknown satellite: {}", - name - ))), + fn new(origin: &Bound<'_, PyAny>) -> PyResult { + if let Ok(origin) = origin.extract::() { + return Ok(Self(origin.try_into()?)); } - } - - fn __repr__(&self) -> String { - format!("Satellite(\"{}\")", self.name()) - } - - fn __str__(&self) -> &str { - self.name() - } - - fn __eq__(&self, other: &Self) -> bool { - self.id() == other.id() - } - - fn __getnewargs__(&self) -> (&str,) { - (self.name(),) - } - - pub fn id(&self) -> i32 { - self.0.id().0 - } - - pub fn name(&self) -> &'static str { - self.0.name() - } - - pub fn gravitational_parameter(&self) -> f64 { - self.0.gravitational_parameter() - } - - pub fn mean_radius(&self) -> f64 { - self.0.mean_radius() - } - - pub fn polar_radius(&self) -> f64 { - self.0.polar_radius() - } - - pub fn subplanetary_radius(&self) -> f64 { - self.0.subplanetary_radius() - } - - pub fn along_orbit_radius(&self) -> f64 { - self.0.along_orbit_radius() - } -} - -#[pyclass(name = "MinorBody", module = "lox_space", frozen)] -#[derive(Clone, Debug)] -pub struct PyMinorBody(Box); - -#[pymethods] -impl PyMinorBody { - #[new] - pub fn new(name: &str) -> PyResult { - let minor: Option> = match name { - "ceres" | "Ceres" => Some(Box::new(Ceres)), - "vesta" | "Vesta" => Some(Box::new(Vesta)), - "psyche" | "Psyche" => Some(Box::new(Psyche)), - "eros" | "Eros" => Some(Box::new(Eros)), - "davida" | "Davida" => Some(Box::new(Davida)), - _ => None, - }; - match minor { - Some(minor) => Ok(Self(minor)), - None => Err(PyValueError::new_err(format!( - "unknown minor body: {}", - name - ))), + if let Ok(origin) = origin.extract::<&str>() { + return Ok(Self(DynOrigin::from_str(origin)?)); } + Err(PyTypeError::new_err( + "`origin` must be either a string or an integer", + )) } fn __repr__(&self) -> String { - format!("MinorBody(\"{}\")", self.name()) + format!("Origin(\"{}\")", self.name()) } fn __str__(&self) -> &str { self.name() } - fn __eq__(&self, other: &Self) -> bool { - self.id() == other.id() - } - fn __getnewargs__(&self) -> (&str,) { (self.name(),) } @@ -401,431 +62,4 @@ impl PyMinorBody { pub fn name(&self) -> &'static str { self.0.name() } - - pub fn gravitational_parameter(&self) -> f64 { - self.0.gravitational_parameter() - } - - pub fn mean_radius(&self) -> f64 { - self.0.mean_radius() - } - - pub fn polar_radius(&self) -> f64 { - self.0.polar_radius() - } - - pub fn subplanetary_radius(&self) -> f64 { - self.0.subplanetary_radius() - } - - pub fn along_orbit_radius(&self) -> f64 { - self.0.along_orbit_radius() - } -} - -#[derive(Debug, Clone)] -pub enum PyBody { - Barycenter(PyBarycenter), - Sun(PySun), - Planet(PyPlanet), - Satellite(PySatellite), - MinorBody(PyMinorBody), -} - -impl From for PyObject { - fn from(body: PyBody) -> Self { - Python::with_gil(|py| match body { - PyBody::Barycenter(barycenter) => barycenter.clone().into_py(py), - PyBody::Sun(sun) => sun.clone().into_py(py), - PyBody::Planet(planet) => planet.clone().into_py(py), - PyBody::Satellite(satellite) => satellite.clone().into_py(py), - PyBody::MinorBody(minor_body) => minor_body.clone().into_py(py), - }) - } -} - -impl TryFrom<&Bound<'_, PyAny>> for PyBody { - type Error = PyErr; - - fn try_from(body: &Bound<'_, PyAny>) -> Result { - if let Ok(body) = body.extract::() { - Ok(PyBody::Barycenter(body)) - } else if let Ok(body) = body.extract::() { - Ok(PyBody::Sun(body)) - } else if let Ok(body) = body.extract::() { - Ok(PyBody::Planet(body)) - } else if let Ok(body) = body.extract::() { - Ok(PyBody::Satellite(body)) - } else if let Ok(body) = body.extract::() { - Ok(PyBody::MinorBody(body)) - } else { - Err(PyValueError::new_err("Invalid body")) - } - } -} - -impl TryFrom>> for PyBody { - type Error = PyErr; - - fn try_from(body: Option<&Bound<'_, PyAny>>) -> Result { - if let Some(body) = body { - return PyBody::try_from(body); - } - Ok(PyBody::Planet(PyPlanet::new("Earth").unwrap())) - } -} - -impl TryFrom for PyBody { - type Error = PyErr; - - // TODO: Use `Bound` API - fn try_from(body: PyObject) -> Result { - Python::with_gil(|py| { - if let Ok(body) = body.extract::(py) { - Ok(PyBody::Barycenter(body)) - } else if let Ok(body) = body.extract::(py) { - Ok(PyBody::Sun(body)) - } else if let Ok(body) = body.extract::(py) { - Ok(PyBody::Planet(body)) - } else if let Ok(body) = body.extract::(py) { - Ok(PyBody::Satellite(body)) - } else if let Ok(body) = body.extract::(py) { - Ok(PyBody::MinorBody(body)) - } else { - Err(PyValueError::new_err("Invalid body")) - } - }) - } -} - -impl Body for PyBody { - fn id(&self) -> NaifId { - match &self { - PyBody::Barycenter(barycenter) => NaifId(barycenter.id()), - PyBody::Sun(sun) => NaifId(sun.id()), - PyBody::Planet(planet) => NaifId(planet.id()), - PyBody::Satellite(satellite) => NaifId(satellite.id()), - PyBody::MinorBody(minor_body) => NaifId(minor_body.id()), - } - } - - fn name(&self) -> &'static str { - match &self { - PyBody::Barycenter(barycenter) => barycenter.name(), - PyBody::Sun(sun) => sun.name(), - PyBody::Planet(planet) => planet.name(), - PyBody::Satellite(satellite) => satellite.name(), - PyBody::MinorBody(minor_body) => minor_body.name(), - } - } -} - -impl PointMass for PyBody { - fn gravitational_parameter(&self) -> f64 { - match &self { - PyBody::Barycenter(barycenter) => barycenter.gravitational_parameter(), - PyBody::Sun(sun) => sun.gravitational_parameter(), - PyBody::Planet(planet) => planet.gravitational_parameter(), - PyBody::Satellite(satellite) => satellite.gravitational_parameter(), - PyBody::MinorBody(minor_body) => minor_body.gravitational_parameter(), - } - } -} - -#[cfg(test)] -mod tests { - use rstest::rstest; - - use super::*; - - #[test] - fn test_sun() { - let sun = PySun::new(); - assert_eq!(sun.__repr__(), "Sun()"); - assert_eq!(sun.__str__(), "Sun"); - assert_eq!(sun.id(), Sun.id().0); - assert_eq!(sun.name(), Sun.name()); - assert_eq!(sun.gravitational_parameter(), Sun.gravitational_parameter()); - assert_eq!(sun.mean_radius(), Sun.mean_radius()); - assert_eq!(sun.polar_radius(), Sun.polar_radius()); - assert_eq!(sun.equatorial_radius(), Sun.equatorial_radius()); - assert!(sun.__eq__(&sun)); - let sun_args = sun.__getnewargs__(); - let empty: Py = Python::with_gil(|py| PyTuple::empty_bound(py).into_py(py)); - assert!(sun_args.is(&empty)); - } - - #[rstest] - #[case("Solar System Barycenter", SolarSystemBarycenter)] - #[case("SSB", SolarSystemBarycenter)] - #[case("Mercury Barycenter", MercuryBarycenter)] - #[case("Venus Barycenter", VenusBarycenter)] - #[case("Earth Barycenter", EarthBarycenter)] - #[case("Mars Barycenter", MarsBarycenter)] - #[case("Jupiter Barycenter", JupiterBarycenter)] - #[case("Saturn Barycenter", SaturnBarycenter)] - #[case("Uranus Barycenter", UranusBarycenter)] - #[case("Neptune Barycenter", NeptuneBarycenter)] - #[case("Pluto Barycenter", PlutoBarycenter)] - fn test_barycenter(#[case] name: &str, #[case] barycenter: impl Barycenter) { - let py_barycenter = PyBarycenter::new(name).expect("barycenter should be valid"); - assert_eq!( - py_barycenter.__repr__(), - format!("Barycenter(\"{}\")", barycenter.name()) - ); - assert_eq!(py_barycenter.__str__(), barycenter.name()); - assert_eq!(py_barycenter.name(), barycenter.name()); - let py_barycenter = - PyBarycenter::new(&name.to_lowercase()).expect("barycenter should be valid"); - assert_eq!( - py_barycenter.__repr__(), - format!("Barycenter(\"{}\")", barycenter.name()) - ); - assert_eq!(py_barycenter.__str__(), barycenter.name()); - assert_eq!(py_barycenter.name(), barycenter.name()); - assert_eq!(py_barycenter.id(), barycenter.id().0); - assert_eq!( - py_barycenter.gravitational_parameter(), - barycenter.gravitational_parameter() - ); - assert_eq!(py_barycenter.__getnewargs__(), (barycenter.name(),)); - assert!(py_barycenter.__eq__(&py_barycenter)); - } - - #[test] - fn test_invalid_barycenter() { - let barycenter = PyBarycenter::new("Rupert Barycenter"); - assert!(barycenter.is_err()); - } - - #[rstest] - #[case("Mercury", Mercury)] - #[case("Venus", Venus)] - #[case("Earth", Earth)] - #[case("Mars", Mars)] - #[case("Jupiter", Jupiter)] - #[case("Saturn", Saturn)] - #[case("Uranus", Uranus)] - #[case("Neptune", Neptune)] - #[case("Pluto", Pluto)] - fn test_planet(#[case] name: &str, #[case] planet: impl Planet) { - let py_planet = PyPlanet::new(name).expect("planet should be valid"); - assert_eq!(py_planet.__repr__(), format!("Planet(\"{}\")", name)); - assert_eq!(py_planet.__str__(), name); - assert_eq!(py_planet.name(), name); - let py_planet = PyPlanet::new(&name.to_lowercase()).expect("planet should be valid"); - assert_eq!(py_planet.__repr__(), format!("Planet(\"{}\")", name)); - assert_eq!(py_planet.__str__(), name); - assert_eq!(py_planet.name(), name); - assert_eq!(py_planet.id(), planet.id().0); - assert_eq!( - py_planet.gravitational_parameter(), - planet.gravitational_parameter() - ); - assert_eq!(py_planet.mean_radius(), planet.mean_radius()); - assert_eq!(py_planet.polar_radius(), planet.polar_radius()); - assert_eq!(py_planet.equatorial_radius(), planet.equatorial_radius()); - assert_eq!(py_planet.__getnewargs__(), (planet.name(),)); - assert!(py_planet.__eq__(&py_planet)); - } - - #[test] - fn test_invalid_planet() { - let planet = PyPlanet::new("Rupert"); - assert!(planet.is_err()); - } - - #[rstest] - #[case("Moon", Moon)] - #[case("Luna", Moon)] - #[case("Phobos", Phobos)] - #[case("Deimos", Deimos)] - #[case("Io", Io)] - #[case("Europa", Europa)] - #[case("Ganymede", Ganymede)] - #[case("Callisto", Callisto)] - #[case("Amalthea", Amalthea)] - #[case("Himalia", Himalia)] - #[case("Thebe", Thebe)] - #[case("Adrastea", Adrastea)] - #[case("Metis", Metis)] - #[case("Mimas", Mimas)] - #[case("Enceladus", Enceladus)] - #[case("Tethys", Tethys)] - #[case("Dione", Dione)] - #[case("Rhea", Rhea)] - #[case("Titan", Titan)] - #[case("Hyperion", Hyperion)] - #[case("Iapetus", Iapetus)] - #[case("Phoebe", Phoebe)] - #[case("Janus", Janus)] - #[case("Epimetheus", Epimetheus)] - #[case("Helene", Helene)] - #[case("Atlas", Atlas)] - #[case("Prometheus", Prometheus)] - #[case("Pandora", Pandora)] - #[case("Ariel", Ariel)] - #[case("Umbriel", Umbriel)] - #[case("Titania", Titania)] - #[case("Oberon", Oberon)] - #[case("Miranda", Miranda)] - #[case("Triton", Triton)] - #[case("Naiad", Naiad)] - #[case("Thalassa", Thalassa)] - #[case("Despina", Despina)] - #[case("Galatea", Galatea)] - #[case("Larissa", Larissa)] - #[case("Proteus", Proteus)] - #[case("Charon", Charon)] - fn test_satellite(#[case] name: &str, #[case] satellite: impl Satellite) { - let py_satellite = PySatellite::new(name).expect("satellite should be valid"); - assert_eq!( - py_satellite.__repr__(), - format!("Satellite(\"{}\")", satellite.name()) - ); - assert_eq!(py_satellite.__str__(), satellite.name()); - assert_eq!(py_satellite.name(), satellite.name()); - let py_satellite = - PySatellite::new(&name.to_lowercase()).expect("satellite should be valid"); - assert_eq!( - py_satellite.__repr__(), - format!("Satellite(\"{}\")", satellite.name()) - ); - assert_eq!(py_satellite.__str__(), satellite.name()); - assert_eq!(py_satellite.name(), satellite.name()); - assert_eq!(py_satellite.id(), satellite.id().0); - assert_eq!( - py_satellite.gravitational_parameter(), - satellite.gravitational_parameter() - ); - assert_eq!(py_satellite.mean_radius(), satellite.mean_radius()); - assert_eq!(py_satellite.polar_radius(), satellite.polar_radius()); - assert_eq!( - py_satellite.subplanetary_radius(), - satellite.subplanetary_radius() - ); - assert_eq!( - py_satellite.along_orbit_radius(), - satellite.along_orbit_radius() - ); - assert_eq!(py_satellite.__getnewargs__(), (satellite.name(),)); - assert!(py_satellite.__eq__(&py_satellite)); - } - - #[test] - fn test_invalid_satellite() { - let satellite = PySatellite::new("Endor"); - assert!(satellite.is_err()); - } - - #[rstest] - #[case("Ceres", Ceres)] - #[case("Vesta", Vesta)] - #[case("Psyche", Psyche)] - #[case("Eros", Eros)] - #[case("Davida", Davida)] - fn test_minor_body(#[case] name: &str, #[case] minor_body: impl MinorBody) { - let py_minor_body = PyMinorBody::new(name).expect("minor body should be valid"); - assert_eq!( - py_minor_body.__repr__(), - format!("MinorBody(\"{}\")", minor_body.name()) - ); - assert_eq!(py_minor_body.__str__(), minor_body.name()); - assert_eq!(py_minor_body.name(), minor_body.name()); - let py_minor_body = - PyMinorBody::new(&name.to_lowercase()).expect("minor body should be valid"); - assert_eq!( - py_minor_body.__repr__(), - format!("MinorBody(\"{}\")", minor_body.name()) - ); - assert_eq!(py_minor_body.__str__(), minor_body.name()); - assert_eq!(py_minor_body.name(), minor_body.name()); - assert_eq!(py_minor_body.id(), minor_body.id().0); - assert_eq!( - py_minor_body.gravitational_parameter(), - minor_body.gravitational_parameter() - ); - assert_eq!(py_minor_body.mean_radius(), minor_body.mean_radius()); - assert_eq!(py_minor_body.polar_radius(), minor_body.polar_radius()); - assert_eq!( - py_minor_body.subplanetary_radius(), - minor_body.subplanetary_radius() - ); - assert_eq!( - py_minor_body.along_orbit_radius(), - minor_body.along_orbit_radius() - ); - assert_eq!(py_minor_body.__getnewargs__(), (minor_body.name(),)); - assert!(py_minor_body.__eq__(&py_minor_body)); - } - - #[test] - fn test_invalid_minor_body() { - let minor_body = PyMinorBody::new("Bielefeld"); - assert!(minor_body.is_err()); - } - - #[test] - fn test_body() { - let sun = PyBody::Sun(PySun::new()); - assert_eq!(sun.id(), Sun.id()); - assert_eq!(sun.name(), Sun.name()); - assert_eq!(sun.gravitational_parameter(), Sun.gravitational_parameter()); - let sun1: PyBody = PyObject::from(sun.clone()) - .try_into() - .expect("sun is valid"); - assert_eq!(sun1.id(), sun.id()); - - let barycenter = PyBody::Barycenter(PyBarycenter::new("ssb").expect("barycenter is valid")); - assert_eq!(barycenter.id(), SolarSystemBarycenter.id()); - assert_eq!(barycenter.name(), SolarSystemBarycenter.name()); - assert_eq!( - barycenter.gravitational_parameter(), - SolarSystemBarycenter.gravitational_parameter() - ); - let barycenter1: PyBody = PyObject::from(barycenter.clone()) - .try_into() - .expect("barycenter is valid"); - assert_eq!(barycenter1.id(), barycenter.id()); - - let planet = PyBody::Planet(PyPlanet::new("earth").expect("planet is valid")); - assert_eq!(planet.id(), Earth.id()); - assert_eq!(planet.name(), Earth.name()); - assert_eq!( - planet.gravitational_parameter(), - Earth.gravitational_parameter() - ); - let planet1: PyBody = PyObject::from(planet.clone()) - .try_into() - .expect("planet is valid"); - assert_eq!(planet1.id(), planet.id()); - - let satellite = PyBody::Satellite(PySatellite::new("moon").expect("satellite is valid")); - assert_eq!(satellite.id(), Moon.id()); - assert_eq!(satellite.name(), Moon.name()); - assert_eq!( - satellite.gravitational_parameter(), - Moon.gravitational_parameter() - ); - let satellite1: PyBody = PyObject::from(satellite.clone()) - .try_into() - .expect("satellite is valid"); - assert_eq!(satellite1.id(), satellite.id()); - - let minor_body = PyBody::MinorBody(PyMinorBody::new("ceres").expect("minor body is valid")); - assert_eq!(minor_body.id(), Ceres.id()); - assert_eq!(minor_body.name(), Ceres.name()); - assert_eq!( - minor_body.gravitational_parameter(), - Ceres.gravitational_parameter() - ); - let minor_body1: PyBody = PyObject::from(minor_body.clone()) - .try_into() - .expect("minor_body is valid"); - assert_eq!(minor_body1.id(), minor_body.id()); - - let obj = Python::with_gil(|py| 1.into_py(py)); - let body = PyBody::try_from(obj); - assert!(body.is_err()); - } } diff --git a/crates/lox-earth/src/cio.rs b/crates/lox-earth/src/cio.rs index c34a26b0..cdf35270 100644 --- a/crates/lox-earth/src/cio.rs +++ b/crates/lox-earth/src/cio.rs @@ -8,4 +8,4 @@ //! Module cio exposes functions for calculating the Celestial Intermediate Origin (CIO) locator, s. -mod s06; +pub mod s06; diff --git a/crates/lox-earth/src/lib.rs b/crates/lox-earth/src/lib.rs index 18f23933..9257b5b0 100644 --- a/crates/lox-earth/src/lib.rs +++ b/crates/lox-earth/src/lib.rs @@ -6,13 +6,11 @@ * file, you can obtain one at https://mozilla.org/MPL/2.0/. */ -// TODO: Remove this once all module components are actively used. -#![allow(dead_code)] - -mod cio; -mod cip; -mod coordinate_transformations; -mod nutation; -mod rotation_angle; -mod tides; -mod tio; +pub mod cio; +pub mod cip; +pub mod coordinate_transformations; +pub mod nutation; +pub mod rotation_angle; +#[allow(dead_code)] +pub mod tides; +pub mod tio; diff --git a/crates/lox-orbits/Cargo.toml b/crates/lox-orbits/Cargo.toml index dd04018d..45ad9395 100644 --- a/crates/lox-orbits/Cargo.toml +++ b/crates/lox-orbits/Cargo.toml @@ -10,6 +10,7 @@ repository.workspace = true [dependencies] lox-bodies.workspace = true +lox-earth.workspace = true lox-ephem.workspace = true lox-time.workspace = true lox-math.workspace = true @@ -26,6 +27,7 @@ thiserror.workspace = true [dev-dependencies] pyo3 = { workspace = true, features = ["auto-initialize"] } +rstest.workspace = true [features] -python = ["dep:pyo3", "dep:numpy", "lox-bodies/python", "lox-time/python"] +python = ["dep:pyo3", "dep:numpy", "lox-bodies/python", "lox-ephem/python", "lox-time/python"] diff --git a/crates/lox-orbits/src/analysis.rs b/crates/lox-orbits/src/analysis.rs index a44be92e..4d1be8e6 100644 --- a/crates/lox-orbits/src/analysis.rs +++ b/crates/lox-orbits/src/analysis.rs @@ -7,22 +7,23 @@ use std::f64::consts::PI; * 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/. */ -use lox_bodies::{RotationalElements, Spheroid}; +use lox_bodies::{MaybeSpheroid, Origin, RotationalElements, Spheroid}; use lox_math::roots::Brent; use lox_math::series::{Series, SeriesError}; use lox_math::types::units::Radians; use lox_time::deltas::TimeDelta; -use lox_time::julian_dates::JulianDate; use lox_time::time_scales::Tdb; use lox_time::transformations::TryToScale; use lox_time::TimeLike; use thiserror::Error; use crate::events::{find_windows, Window}; -use crate::frames::{BodyFixed, FrameTransformationProvider, Icrf, Topocentric, TryToFrame}; -use crate::ground::GroundLocation; -use crate::origins::{CoordinateOrigin, Origin}; -use crate::trajectories::Trajectory; +use crate::frames::{ + BodyFixed, DynFrame, FrameTransformationProvider, Icrf, TryRotateTo, TryToFrame, +}; +use crate::ground::{DynGroundLocation, GroundLocation}; +use crate::states::State; +use crate::trajectories::{DynTrajectory, Trajectory}; #[derive(Debug, Clone, Error, PartialEq)] pub enum ElevationMaskError { @@ -62,37 +63,59 @@ impl ElevationMask { } } -pub fn elevation< - T: TimeLike + TryToScale + Clone, - O: Origin + Spheroid + RotationalElements + Clone, - P: FrameTransformationProvider, ->( +pub fn elevation_dyn + Clone, P: FrameTransformationProvider>( time: T, - frame: &Topocentric, - gs: &Trajectory, - sc: &Trajectory, + gs: &DynGroundLocation, + mask: &ElevationMask, + sc: &DynTrajectory, provider: &P, ) -> Radians { - let body_fixed = BodyFixed(gs.origin()); - let gs = gs.interpolate_at(time.clone()).position(); - let sc = sc.interpolate_at(time.clone()).position(); - let r = sc - gs; - let Ok(tdb) = time.try_to_scale(Tdb, provider) else { - // FIXME - eprintln!("Failed to convert time to TDB"); - return f64::NAN; - }; - let seconds = tdb.seconds_since_j2000(); - let rot = body_fixed.rotation(seconds); - let r_body = rot.rotate_position(r); - let rot = frame.rotation_from_body_fixed(); - let r_sez = rot * r_body; - (r_sez.z / r.length()).asin() + let body_fixed = DynFrame::BodyFixed(gs.origin()); + let sc = sc.interpolate_at(time.clone()); + let rot = DynFrame::Icrf.try_rotation(&body_fixed, time, provider); + let (r1, v1) = rot.unwrap().rotate_state(sc.position(), sc.velocity()); + let sc = State::new(sc.time(), r1, v1, sc.origin(), body_fixed); + let obs = gs.observables_dyn(sc); + obs.elevation() - mask.min_elevation(obs.azimuth()) } -pub fn elevation2< +pub fn visibility_dyn + Clone, P: FrameTransformationProvider>( + times: &[T], + gs: &DynGroundLocation, + mask: &ElevationMask, + sc: &DynTrajectory, + provider: &P, +) -> Vec> { + if times.len() < 2 { + return vec![]; + } + let start = times.first().unwrap().clone(); + let end = times.last().unwrap().clone(); + let times: Vec = times + .iter() + .map(|t| (t.clone() - start.clone()).to_decimal_seconds()) + .collect(); + let root_finder = Brent::default(); + find_windows( + |t| { + elevation_dyn( + start.clone() + TimeDelta::from_decimal_seconds(t).unwrap(), + gs, + mask, + sc, + provider, + ) + }, + start.clone(), + end.clone(), + ×, + root_finder, + ) +} + +pub fn elevation< T: TimeLike + TryToScale + Clone, - O: Origin + Spheroid + RotationalElements + Clone, + O: Origin + MaybeSpheroid + RotationalElements + Clone, P: FrameTransformationProvider, >( time: T, @@ -131,7 +154,7 @@ pub fn visibility< let root_finder = Brent::default(); find_windows( |t| { - elevation2( + elevation( start.clone() + TimeDelta::from_decimal_seconds(t).unwrap(), gs, mask, @@ -165,7 +188,7 @@ mod tests { fn test_elevation() { let gs = ground_station_trajectory(); let sc = spacecraft_trajectory(); - let frame = frame(); + let mask = ElevationMask::with_fixed_elevation(0.0); let expected: Vec = include_str!("../../../data/elevation.csv") .lines() .map(|line| line.parse::().unwrap().to_radians()) @@ -173,7 +196,15 @@ mod tests { let actual: Vec = gs .times() .iter() - .map(|t| elevation(*t, &frame, &gs, &sc, &NoOpFrameTransformationProvider)) + .map(|t| { + elevation( + *t, + &location(), + &mask, + &sc, + &NoOpFrameTransformationProvider, + ) + }) .collect(); for (actual, expected) in actual.iter().zip(expected.iter()) { assert_close!(actual, expected, 1e-1); @@ -238,12 +269,6 @@ mod tests { GroundLocation::new(longitude, latitude, 0.0, Earth) } - fn frame() -> Topocentric { - let longitude = -4.3676f64.to_radians(); - let latitude = 40.4527f64.to_radians(); - Topocentric::from_coords(longitude, latitude, 0.0, Earth) - } - fn contacts() -> Vec>> { let mut windows = vec![]; let mut reader = diff --git a/crates/lox-orbits/src/elements.rs b/crates/lox-orbits/src/elements.rs index 68e21618..80644261 100644 --- a/crates/lox-orbits/src/elements.rs +++ b/crates/lox-orbits/src/elements.rs @@ -11,22 +11,28 @@ use std::f64::consts::TAU; use float_eq::float_eq; use glam::{DMat3, DVec3}; -use lox_bodies::PointMass; +use lox_bodies::{DynOrigin, MaybePointMass, PointMass}; use lox_time::deltas::TimeDelta; use lox_time::TimeLike; -use crate::frames::{CoordinateSystem, Icrf}; -use crate::origins::CoordinateOrigin; -use crate::states::{State, ToCartesian}; +use crate::frames::{CoordinateSystem, DynFrame, Icrf, ReferenceFrame}; +use crate::states::State; -pub trait ToKeplerian { - fn to_keplerian(&self) -> Keplerian; +#[derive(Debug, Clone, PartialEq)] +pub(crate) struct KeplerianElements { + pub semi_major_axis: f64, + pub eccentricity: f64, + pub inclination: f64, + pub longitude_of_ascending_node: f64, + pub argument_of_periapsis: f64, + pub true_anomaly: f64, } #[derive(Debug, Clone, PartialEq)] -pub struct Keplerian { +pub struct Keplerian { time: T, origin: O, + frame: R, semi_major_axis: f64, eccentricity: f64, inclination: f64, @@ -35,7 +41,9 @@ pub struct Keplerian { true_anomaly: f64, } -impl Keplerian +pub type DynKeplerian = Keplerian; + +impl Keplerian where T: TimeLike, O: PointMass, @@ -54,6 +62,7 @@ where Self { time, origin, + frame: Icrf, semi_major_axis, eccentricity, inclination, @@ -62,6 +71,52 @@ where true_anomaly, } } +} + +impl DynKeplerian +where + T: TimeLike, +{ + #[allow(clippy::too_many_arguments)] + pub fn with_dynamic( + time: T, + origin: DynOrigin, + semi_major_axis: f64, + eccentricity: f64, + inclination: f64, + longitude_of_ascending_node: f64, + argument_of_periapsis: f64, + true_anomaly: f64, + ) -> Result { + if origin.maybe_gravitational_parameter().is_none() { + return Err("undefined gravitational parameter"); + } + Ok(Self { + time, + origin, + frame: DynFrame::Icrf, + semi_major_axis, + eccentricity, + inclination, + longitude_of_ascending_node, + argument_of_periapsis, + true_anomaly, + }) + } +} + +impl Keplerian +where + T: TimeLike, + O: MaybePointMass, + R: ReferenceFrame, +{ + pub fn origin(&self) -> O + where + O: Clone, + { + self.origin.clone() + } pub fn time(&self) -> T where @@ -70,6 +125,12 @@ where self.time.clone() } + pub fn gravitational_parameter(&self) -> f64 { + self.origin + .maybe_gravitational_parameter() + .expect("gravitational parameter should be available") + } + pub fn semi_major_axis(&self) -> f64 { self.semi_major_axis } @@ -101,9 +162,8 @@ where self.semi_major_axis * (1.0 - self.eccentricity.powi(2)) } } - pub fn to_perifocal(&self) -> (DVec3, DVec3) { - let grav_param = self.origin.gravitational_parameter(); + let grav_param = self.gravitational_parameter(); let semiparameter = self.semiparameter(); let (sin_nu, cos_nu) = self.true_anomaly.sin_cos(); let sqrt_mu_p = (grav_param / semiparameter).sqrt(); @@ -116,35 +176,38 @@ where } pub fn orbital_period(&self) -> TimeDelta { - let mu = self.origin.gravitational_parameter(); + let mu = self.gravitational_parameter(); let a = self.semi_major_axis(); TimeDelta::from_decimal_seconds(TAU * (a.powi(3) / mu).sqrt()).unwrap() } } -impl CoordinateOrigin for Keplerian { - fn origin(&self) -> O { - self.origin.clone() - } -} - -impl CoordinateSystem for Keplerian { - fn reference_frame(&self) -> Icrf { - Icrf +impl CoordinateSystem + for Keplerian +{ + fn reference_frame(&self) -> R { + self.frame.clone() } } -impl ToCartesian for Keplerian +impl Keplerian where T: TimeLike + Clone, - O: PointMass + Clone, + O: MaybePointMass + Clone, + R: ReferenceFrame + Clone, { - fn to_cartesian(&self) -> State { + pub(crate) fn to_cartesian(&self) -> State { let (pos, vel) = self.to_perifocal(); let rot = DMat3::from_rotation_z(self.longitude_of_ascending_node) * DMat3::from_rotation_x(self.inclination) * DMat3::from_rotation_z(self.argument_of_periapsis); - State::new(self.time(), rot * pos, rot * vel, self.origin(), Icrf) + State::new( + self.time(), + rot * pos, + rot * vel, + self.origin(), + self.reference_frame(), + ) } } diff --git a/crates/lox-orbits/src/ensembles.rs b/crates/lox-orbits/src/ensembles.rs index 4f7bc3c5..66004b58 100644 --- a/crates/lox-orbits/src/ensembles.rs +++ b/crates/lox-orbits/src/ensembles.rs @@ -7,8 +7,8 @@ */ use crate::frames::ReferenceFrame; -use crate::origins::Origin; use crate::trajectories::Trajectory; +use lox_bodies::Origin; use lox_time::TimeLike; use std::collections::HashMap; diff --git a/crates/lox-orbits/src/frames.rs b/crates/lox-orbits/src/frames.rs index a502e0d0..57c5e86e 100644 --- a/crates/lox-orbits/src/frames.rs +++ b/crates/lox-orbits/src/frames.rs @@ -6,20 +6,26 @@ * file, you can obtain one at https://mozilla.org/MPL/2.0/. */ -use std::convert::Infallible; -use std::f64::consts::FRAC_PI_2; - -use crate::ground::GroundLocation; +use crate::frames::iau::{icrf_to_bodyfixed, IcrfToBodyFixedError}; +use crate::frames::iers::{cirf_to_tirf, icrf_to_cirf, tirf_to_itrf}; +use crate::rotations::Rotation; use glam::{DMat3, DVec3}; -use lox_bodies::{RotationalElements, Spheroid}; +use lox_bodies::{DynOrigin, Origin, RotationalElements, TryRotationalElements}; use lox_math::types::units::Seconds; -use lox_time::transformations::OffsetProvider; +use lox_time::time_scales::Tdb; +use lox_time::transformations::{OffsetProvider, TryToScale}; +use lox_time::TimeLike; +use std::f64::consts::{FRAC_PI_2, TAU}; +use std::{convert::Infallible, str::FromStr}; +use thiserror::Error; -use crate::rotations::Rotation; +pub mod iau; +pub mod iers; pub trait ReferenceFrame { fn name(&self) -> String; fn abbreviation(&self) -> String; + fn is_rotating(&self) -> bool; } pub trait CoordinateSystem { @@ -54,6 +60,61 @@ impl ReferenceFrame for Icrf { fn abbreviation(&self) -> String { "ICRF".to_string() } + + fn is_rotating(&self) -> bool { + false + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Ord, PartialOrd)] +pub struct Cirf; + +impl ReferenceFrame for Cirf { + fn name(&self) -> String { + "Celestial Intermediate Reference Frame".to_string() + } + + fn abbreviation(&self) -> String { + "CIRF".to_string() + } + + fn is_rotating(&self) -> bool { + false + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Ord, PartialOrd)] +pub struct Tirf; + +impl ReferenceFrame for Tirf { + fn name(&self) -> String { + "Terrestrial Intermediate Reference Frame".to_string() + } + + fn abbreviation(&self) -> String { + "TIRF".to_string() + } + + fn is_rotating(&self) -> bool { + true + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Ord, PartialOrd)] +pub struct Itrf; + +impl ReferenceFrame for Itrf { + fn name(&self) -> String { + "International Terrestrial Reference Frame".to_string() + } + + fn abbreviation(&self) -> String { + "ITRF".to_string() + } + + fn is_rotating(&self) -> bool { + true + } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Ord, PartialOrd)] @@ -61,14 +122,14 @@ pub struct BodyFixed(pub T); impl BodyFixed { pub fn rotation(&self, seconds: Seconds) -> Rotation { - let (right_ascension, declination, prime_meridian) = self.0.rotational_elements(seconds); - let (right_ascension_rate, declination_rate, prime_meridian_rate) = + let (right_ascension, declination, rotation_angle) = self.0.rotational_elements(seconds); + let (right_ascension_rate, declination_rate, rotation_rate) = self.0.rotational_element_rates(seconds); - let m1 = DMat3::from_rotation_z(-right_ascension); - let m2 = DMat3::from_rotation_x(-declination); - let m3 = DMat3::from_rotation_z(-prime_meridian); + let m1 = DMat3::from_rotation_z(-(right_ascension + FRAC_PI_2)); + let m2 = DMat3::from_rotation_x(-(FRAC_PI_2 - declination)); + let m3 = DMat3::from_rotation_z(-(rotation_angle % TAU)); let m = m3 * m2 * m1; - let v = DVec3::new(right_ascension_rate, declination_rate, prime_meridian_rate); + let v = DVec3::new(right_ascension_rate, -declination_rate, rotation_rate); Rotation::new(m).with_angular_velocity(v) } } @@ -86,52 +147,244 @@ impl ReferenceFrame for BodyFixed { let body = self.0.name().replace([' ', '-'], "_").to_uppercase(); format!("IAU_{}", body) } + + fn is_rotating(&self) -> bool { + true + } } -#[derive(Clone, Debug)] -pub struct Topocentric(GroundLocation); +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)] +pub enum DynFrame { + #[default] + Icrf, + Cirf, + Tirf, + Itrf, + BodyFixed(DynOrigin), +} -impl Topocentric { - pub fn new(location: GroundLocation) -> Self { - Topocentric(location) +impl ReferenceFrame for DynFrame { + fn name(&self) -> String { + match self { + DynFrame::Icrf => Icrf.name(), + DynFrame::Cirf => Cirf.name(), + DynFrame::Tirf => Tirf.name(), + DynFrame::Itrf => Itrf.name(), + DynFrame::BodyFixed(dyn_origin) => { + let body = dyn_origin.name(); + match body { + "Sun" | "Moon" => format!("IAU Body-Fixed Reference Frame for the {}", body), + _ => format!("IAU Body-Fixed Reference Frame for {}", body), + } + } + } + } + + fn abbreviation(&self) -> String { + match self { + DynFrame::Icrf => Icrf.abbreviation(), + DynFrame::Cirf => Cirf.abbreviation(), + DynFrame::Tirf => Tirf.abbreviation(), + DynFrame::Itrf => Itrf.abbreviation(), + DynFrame::BodyFixed(dyn_origin) => { + let body = dyn_origin.name().replace([' ', '-'], "_").to_uppercase(); + format!("IAU_{}", body) + } + } } - pub fn from_coords(longitude: f64, latitude: f64, altitude: f64, body: B) -> Self { - let location = GroundLocation::new(longitude, latitude, altitude, body); - Topocentric(location) + fn is_rotating(&self) -> bool { + match self { + DynFrame::Icrf | DynFrame::Cirf => false, + DynFrame::Tirf | DynFrame::Itrf | DynFrame::BodyFixed(_) => true, + } } +} - pub fn rotation_from_body_fixed(&self) -> DMat3 { - let r1 = DMat3::from_rotation_z(self.0.longitude()).transpose(); - let r2 = DMat3::from_rotation_y(FRAC_PI_2 - self.0.latitude()).transpose(); - r2 * r1 +fn parse_iau_frame(s: &str) -> Option { + let (prefix, origin) = s.split_once("_")?; + if prefix.to_lowercase() != "iau" { + return None; + } + let origin: DynOrigin = origin.to_lowercase().parse().ok()?; + let _ = origin.try_rotational_elements(0.0).ok()?; + Some(DynFrame::BodyFixed(origin)) +} + +#[derive(Clone, Debug, Error, PartialEq, Eq)] +#[error("no frame with name '{0}' is known")] +pub struct UnknownFrameError(String); + +impl FromStr for DynFrame { + type Err = UnknownFrameError; + + fn from_str(s: &str) -> Result { + match s { + "icrf" | "ICRF" => Ok(DynFrame::Icrf), + "cirf" | "CIRF" => Ok(DynFrame::Cirf), + "tirf" | "TIRF" => Ok(DynFrame::Tirf), + "itrf" | "ITRF" => Ok(DynFrame::Itrf), + _ => { + if let Some(frame) = parse_iau_frame(s) { + Ok(frame) + } else { + Err(UnknownFrameError(s.to_owned())) + } + } + } + } +} + +pub trait TryRotateTo { + type Error; + + fn try_rotation + Clone>( + &self, + frame: &R, + time: T, + provider: &P, + ) -> Result; +} + +impl TryRotateTo for DynFrame { + // FIXME + type Error = IcrfToBodyFixedError; + + fn try_rotation + Clone>( + &self, + frame: &DynFrame, + time: T, + provider: &P, + ) -> Result { + // FIXME + let seconds_j2000 = time.seconds_since_j2000(); + let centuries_j2000 = time.centuries_since_j2000(); + match self { + DynFrame::Icrf => match frame { + DynFrame::Icrf => Ok(Rotation::IDENTITY), + DynFrame::Cirf => Ok(icrf_to_cirf(centuries_j2000)), + DynFrame::Tirf => { + Ok(icrf_to_cirf(centuries_j2000).compose(&cirf_to_tirf(seconds_j2000))) + } + DynFrame::Itrf => Ok(icrf_to_cirf(centuries_j2000) + .compose(&cirf_to_tirf(seconds_j2000)) + .compose(&tirf_to_itrf(centuries_j2000))), + DynFrame::BodyFixed(target) => icrf_to_bodyfixed(time, target, provider), + }, + DynFrame::Cirf => match frame { + DynFrame::Icrf => Ok(icrf_to_cirf(centuries_j2000).transpose()), + DynFrame::Cirf => Ok(Rotation::IDENTITY), + DynFrame::Tirf => Ok(cirf_to_tirf(seconds_j2000)), + DynFrame::Itrf => { + Ok(cirf_to_tirf(seconds_j2000).compose(&tirf_to_itrf(centuries_j2000))) + } + DynFrame::BodyFixed(_) => Ok(self + .try_rotation(&DynFrame::Icrf, time.clone(), provider)? + .compose(&DynFrame::Icrf.try_rotation(frame, time, provider)?)), + }, + DynFrame::Tirf => match frame { + DynFrame::Icrf => Ok(cirf_to_tirf(seconds_j2000) + .transpose() + .compose(&icrf_to_cirf(centuries_j2000).transpose())), + DynFrame::Cirf => Ok(cirf_to_tirf(seconds_j2000).transpose()), + DynFrame::Tirf => Ok(Rotation::IDENTITY), + DynFrame::Itrf => Ok(tirf_to_itrf(centuries_j2000)), + DynFrame::BodyFixed(_) => Ok(self + .try_rotation(&DynFrame::Icrf, time.clone(), provider)? + .compose(&DynFrame::Icrf.try_rotation(frame, time, provider)?)), + }, + DynFrame::Itrf => match frame { + DynFrame::Icrf => Ok(tirf_to_itrf(centuries_j2000) + .transpose() + .compose(&cirf_to_tirf(seconds_j2000).transpose()) + .compose(&icrf_to_cirf(centuries_j2000).transpose())), + DynFrame::Cirf => Ok(tirf_to_itrf(centuries_j2000) + .transpose() + .compose(&cirf_to_tirf(seconds_j2000).transpose())), + DynFrame::Tirf => Ok(tirf_to_itrf(centuries_j2000).transpose()), + DynFrame::Itrf => Ok(Rotation::IDENTITY), + DynFrame::BodyFixed(_) => Ok(self + .try_rotation(&DynFrame::Icrf, time.clone(), provider)? + .compose(&DynFrame::Icrf.try_rotation(frame, time, provider)?)), + }, + DynFrame::BodyFixed(origin) => match frame { + DynFrame::Icrf => Ok(icrf_to_bodyfixed(time, origin, provider)?.transpose()), + DynFrame::Cirf => Ok(self + .try_rotation(&DynFrame::Icrf, time.clone(), provider)? + .compose(&DynFrame::Icrf.try_rotation(frame, time, provider)?)), + DynFrame::Tirf => Ok(self + .try_rotation(&DynFrame::Icrf, time.clone(), provider)? + .compose(&DynFrame::Icrf.try_rotation(frame, time, provider)?)), + DynFrame::Itrf => Ok(self + .try_rotation(&DynFrame::Icrf, time.clone(), provider)? + .compose(&DynFrame::Icrf.try_rotation(frame, time, provider)?)), + DynFrame::BodyFixed(target) => { + if origin == target { + Ok(Rotation::IDENTITY) + } else { + Ok(self + .try_rotation(&DynFrame::Icrf, time.clone(), provider)? + .compose(&DynFrame::Icrf.try_rotation(frame, time, provider)?)) + } + } + }, + } } } #[cfg(test)] mod tests { use super::*; - use lox_bodies::Earth; use lox_math::assert_close; use lox_math::is_close::IsClose; + use lox_time::transformations::ToTai; + use lox_time::utc::Utc; + use rstest::rstest; + + #[rstest] + #[case("IAU_EARTH", Some(DynFrame::BodyFixed(DynOrigin::Earth)))] + #[case("FOO_EARTH", None)] + #[case("IAU_RUPERT", None)] + #[case("IAU_SYCORAX", None)] + fn test_parse_iau_frame(#[case] name: &str, #[case] exp: Option) { + let act = parse_iau_frame(name); + assert_eq!(act, exp) + } - #[test] - fn test_topocentric() { - let topo = Topocentric::from_coords(8.0, 50.0, 0.0, Earth); - let r = topo.rotation_from_body_fixed(); - let x_axis = DVec3::new( - 0.038175550084451906, - -0.9893582466233818, - -0.14040258976976597, - ); - let y_axis = DVec3::new( - -0.25958272521858694, - -0.14550003380861354, - 0.9546970980000851, - ); - let z_axis = DVec3::new(-0.9649660284921128, 0.0, -0.2623748537039304); - assert_close!(r.x_axis, x_axis); - assert_close!(r.y_axis, y_axis); - assert_close!(r.z_axis, z_axis); + #[rstest] + #[case( + DynFrame::BodyFixed(DynOrigin::Earth), + DVec3::new( + -5.740_259_426_667_957e3, + 3.121_136_072_795_472_5e3, + -1.863_182_656_331_802_7e3, + ), + DVec3::new( + -3.532_378_757_836_52, + -3.152_377_656_863_808, + 5.642_296_713_889_555, + ), + )] + #[case( + DynFrame::BodyFixed(DynOrigin::Moon), + DVec3::new( + 3.777_805_761_337_502e3, + -5.633_812_666_439_680_5e3, + -3.896_880_165_980_424e2, + ), + DVec3::new( + 2.576_901_711_027_508_3, + 1.250_106_874_006_032_4, + 7.100_615_382_464_156, + ), + )] + fn test_icrf_to_bodyfixed(#[case] frame: DynFrame, #[case] r_exp: DVec3, #[case] v_exp: DVec3) { + let time = Utc::from_iso("2024-07-05T09:09:18.173").unwrap().to_tai(); + let r = DVec3::new(-5530.01774359, -3487.0895338, -1850.03476185); + let v = DVec3::new(1.29534407, -5.02456882, 5.6391936); + let rot = DynFrame::Icrf.try_rotation(&frame, time, &NoOpFrameTransformationProvider); + let (r_act, v_act) = rot.unwrap().rotate_state(r, v); + assert_close!(r_act, r_exp, 1e-8); + assert_close!(v_act, v_exp, 1e-5); } } diff --git a/crates/lox-orbits/src/frames/iau.rs b/crates/lox-orbits/src/frames/iau.rs new file mode 100644 index 00000000..475f0ebe --- /dev/null +++ b/crates/lox-orbits/src/frames/iau.rs @@ -0,0 +1,64 @@ +/* + * 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/. + */ +use crate::rotations::Rotation; +use glam::{DMat3, DVec3}; +use lox_bodies::{TryRotationalElements, UndefinedRotationalElementsError}; +use lox_time::julian_dates::JulianDate; +use lox_time::time_scales::Tdb; +use lox_time::transformations::{OffsetProvider, TryToScale}; +use lox_time::TimeLike; +use std::f64::consts::{FRAC_PI_2, TAU}; +use thiserror::Error; + +#[derive(Clone, Debug, Error)] +pub enum IcrfToBodyFixedError { + #[error(transparent)] + UndefinedRotationalElements(#[from] UndefinedRotationalElementsError), + #[error("time error: {0}")] + TimeError(String), +} + +pub(crate) fn icrf_to_bodyfixed< + P: OffsetProvider, + T: TimeLike + TryToScale, + O: TryRotationalElements, +>( + time: T, + body: &O, + provider: &P, +) -> Result { + let seconds = time + .try_to_scale(Tdb, provider) + .map_err(|err| IcrfToBodyFixedError::TimeError(err.to_string()))? + .seconds_since_j2000(); + let (right_ascension, declination, rotation_angle) = body.try_rotational_elements(seconds)?; + let (right_ascension_rate, declination_rate, rotation_rate) = + body.try_rotational_element_rates(seconds)?; + + let m1 = DMat3::from_rotation_z(-(right_ascension + FRAC_PI_2)); + let m2 = DMat3::from_rotation_x(-(FRAC_PI_2 - declination)); + let m3 = DMat3::from_rotation_z(-(rotation_angle % TAU)); + let m = m3 * m2 * m1; + let v = DVec3::new(right_ascension_rate, -declination_rate, rotation_rate); + Ok(Rotation::new(m).with_angular_velocity(v)) +} +// +// impl TryRotateTo, P> for Icrf { +// type Error = (); +// +// fn try_rotation( +// &self, +// frame: &BodyFixed, +// time: T, +// _provider: &P, +// ) -> Result { +// // FIXME +// let seconds = time.seconds_since_j2000(); +// Ok(icrf_to_bodyfixed(&frame.0, seconds).unwrap()) +// } +// } diff --git a/crates/lox-orbits/src/frames/iers.rs b/crates/lox-orbits/src/frames/iers.rs new file mode 100644 index 00000000..1006206c --- /dev/null +++ b/crates/lox-orbits/src/frames/iers.rs @@ -0,0 +1,42 @@ +/* + * 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/. + */ +use crate::rotations::Rotation; +use glam::{DMat3, DVec2, DVec3}; +use lox_bodies::{Earth, RotationalElements}; +use lox_earth::cio::s06::s; +use lox_earth::cip::xy06::xy; +use lox_earth::coordinate_transformations::{ + celestial_to_intermediate_frame_of_date_matrix, polar_motion_matrix, +}; +use lox_earth::rotation_angle::RotationAngle; +use lox_earth::tio::sp_00; +use lox_math::constants::f64::time::SECONDS_PER_DAY; + +pub fn icrf_to_cirf(centuries: f64) -> Rotation { + // TODO: Add IERS corrections + let cip_coords = xy(centuries); + let cio_locator = s(centuries, cip_coords); + let m = celestial_to_intermediate_frame_of_date_matrix(cip_coords, cio_locator); + Rotation::new(m) +} + +pub fn cirf_to_tirf(seconds: f64) -> Rotation { + let era = Earth::rotation_angle_00(seconds / SECONDS_PER_DAY); + let rate = Earth.rotation_rate(seconds); + let m = DMat3::from_rotation_z(-era); + let v = DVec3::new(0.0, 0.0, rate); + Rotation::new(m).with_angular_velocity(v) +} + +pub fn tirf_to_itrf(centuries: f64) -> Rotation { + // TODO: Add IERS corrections + let pole_coords: DVec2 = (0.0, 0.0).into(); + let tio_locator = sp_00(centuries); + let m = polar_motion_matrix(pole_coords, tio_locator); + Rotation::new(m) +} diff --git a/crates/lox-orbits/src/ground.rs b/crates/lox-orbits/src/ground.rs index 5dd55fed..60458901 100644 --- a/crates/lox-orbits/src/ground.rs +++ b/crates/lox-orbits/src/ground.rs @@ -11,17 +11,20 @@ use std::f64::consts::FRAC_PI_2; use glam::{DMat3, DVec3}; use thiserror::Error; -use lox_bodies::{RotationalElements, Spheroid}; +use lox_bodies::{DynOrigin, MaybeSpheroid, RotationalElements, Spheroid}; use lox_math::types::units::Radians; use lox_time::prelude::Tdb; use lox_time::transformations::TryToScale; use lox_time::TimeLike; -use crate::frames::{BodyFixed, CoordinateSystem, FrameTransformationProvider, Icrf, TryToFrame}; -use crate::origins::CoordinateOrigin; +use crate::frames::iau::IcrfToBodyFixedError; +use crate::frames::{ + BodyFixed, CoordinateSystem, DynFrame, FrameTransformationProvider, Icrf, ReferenceFrame, + TryRotateTo, TryToFrame, +}; use crate::propagators::Propagator; -use crate::states::State; -use crate::trajectories::TrajectoryError; +use crate::states::{DynState, State}; +use crate::trajectories::{DynTrajectory, Trajectory, TrajectoryError}; #[derive(Clone, Debug)] pub struct Observables { @@ -58,13 +61,15 @@ impl Observables { } #[derive(Clone, Debug)] -pub struct GroundLocation { +pub struct GroundLocation { longitude: f64, latitude: f64, altitude: f64, body: B, } +pub type DynGroundLocation = GroundLocation; + impl GroundLocation { pub fn new(longitude: f64, latitude: f64, altitude: f64, body: B) -> Self { GroundLocation { @@ -74,14 +79,33 @@ impl GroundLocation { body, } } +} - pub fn with_body(self, body: T) -> GroundLocation { - GroundLocation { - longitude: self.longitude, - latitude: self.latitude, - altitude: self.altitude, - body, +impl DynGroundLocation { + pub fn with_dynamic( + longitude: f64, + latitude: f64, + altitude: f64, + body: DynOrigin, + ) -> Result { + if body.maybe_equatorial_radius().is_none() { + return Err("no spheroid"); } + Ok(GroundLocation { + longitude, + latitude, + altitude, + body, + }) + } +} + +impl GroundLocation { + pub fn origin(&self) -> B + where + B: Clone, + { + self.body.clone() } pub fn longitude(&self) -> f64 { @@ -96,12 +120,24 @@ impl GroundLocation { self.altitude } + fn equatorial_radius(&self) -> f64 { + self.body + .maybe_equatorial_radius() + .expect("equatorial radius should be available") + } + + fn flattening(&self) -> f64 { + self.body + .maybe_flattening() + .expect("flattening should be available") + } + pub fn body_fixed_position(&self) -> DVec3 { let alt = self.altitude; let (lon_sin, lon_cos) = self.longitude.sin_cos(); let (lat_sin, lat_cos) = self.latitude.sin_cos(); - let f = self.body.flattening(); - let r_eq = self.body.equatorial_radius(); + let f = self.flattening(); + let r_eq = self.equatorial_radius(); let e = (2.0 * f - f.powi(2)).sqrt(); let c = r_eq / (1.0 - e.powi(2) * lat_sin.powi(2)).sqrt(); let s = c * (1.0 - e.powi(2)); @@ -134,11 +170,21 @@ impl GroundLocation { range_rate, } } -} -impl CoordinateOrigin for GroundLocation { - fn origin(&self) -> O { - self.body.clone() + pub fn observables_dyn(&self, state: DynState) -> Observables { + let rot = self.rotation_to_topocentric(); + let position = rot * (state.position() - self.body_fixed_position()); + let velocity = rot * state.velocity(); + let range = position.length(); + let range_rate = position.dot(velocity) / range; + let elevation = (position.z / range).asin(); + let azimuth = position.y.atan2(-position.x); + Observables { + azimuth, + elevation, + range, + range_rate, + } } } @@ -148,45 +194,85 @@ pub enum GroundPropagatorError { FrameTransformationError(String), #[error(transparent)] TrajectoryError(#[from] TrajectoryError), + #[error(transparent)] + IcrfToBodyFixedError(#[from] IcrfToBodyFixedError), } -pub struct GroundPropagator { +pub struct GroundPropagator { location: GroundLocation, + frame: R, // FIXME: We should not take ownership of the provider here provider: P, } -impl GroundPropagator +pub type DynGroundPropagator

= GroundPropagator; + +impl GroundPropagator where B: Spheroid, P: FrameTransformationProvider, { pub fn new(location: GroundLocation, provider: P) -> Self { - GroundPropagator { location, provider } + GroundPropagator { + location, + frame: Icrf, + provider, + } } } -impl CoordinateOrigin for GroundPropagator -where - O: Spheroid + Clone, - P: FrameTransformationProvider, -{ - fn origin(&self) -> O { - self.location.body.clone() +impl DynGroundPropagator

{ + pub fn with_dynamic(location: DynGroundLocation, provider: P) -> Self { + GroundPropagator { + location, + frame: DynFrame::Icrf, + provider, + } + } + + pub fn propagate_dyn + Clone>( + &self, + time: T, + ) -> Result, GroundPropagatorError> { + let s = State::new( + time.clone(), + self.location.body_fixed_position(), + DVec3::ZERO, + self.location.body, + DynFrame::BodyFixed(self.location.body), + ); + let rot = + s.reference_frame() + .try_rotation(&DynFrame::Icrf, time.clone(), &self.provider)?; + let (r1, v1) = rot.rotate_state(s.position(), s.velocity()); + Ok(State::new(time, r1, v1, self.location.body, DynFrame::Icrf)) + } + + pub(crate) fn propagate_all_dyn + Clone>( + &self, + times: impl IntoIterator, + ) -> Result, GroundPropagatorError> { + let mut states = vec![]; + for time in times { + let state = self.propagate_dyn(time)?; + states.push(state); + } + Ok(Trajectory::new(&states)?) } } -impl CoordinateSystem for GroundPropagator +impl CoordinateSystem for GroundPropagator where O: Spheroid, + R: ReferenceFrame + Clone, P: FrameTransformationProvider, { - fn reference_frame(&self) -> Icrf { - Icrf + fn reference_frame(&self) -> R { + self.frame.clone() } } -impl Propagator for GroundPropagator +impl Propagator for GroundPropagator where T: TimeLike + TryToScale + Clone, O: Spheroid + RotationalElements + Clone, @@ -202,7 +288,7 @@ where self.location.body.clone(), BodyFixed(self.location.body.clone()), ) - .try_to_frame(Icrf, &self.provider) + .try_to_frame(self.frame, &self.provider) .map_err(|err| GroundPropagatorError::FrameTransformationError(err.to_string())) } } diff --git a/crates/lox-orbits/src/lib.rs b/crates/lox-orbits/src/lib.rs index de51c21e..d0226a85 100644 --- a/crates/lox-orbits/src/lib.rs +++ b/crates/lox-orbits/src/lib.rs @@ -15,7 +15,6 @@ pub mod ensembles; pub mod events; pub mod frames; pub mod ground; -pub mod origins; pub mod propagators; #[cfg(feature = "python")] pub mod python; diff --git a/crates/lox-orbits/src/origins.rs b/crates/lox-orbits/src/origins.rs deleted file mode 100644 index 01902dcc..00000000 --- a/crates/lox-orbits/src/origins.rs +++ /dev/null @@ -1,9 +0,0 @@ -use lox_bodies::Body; - -pub trait Origin {} - -impl Origin for U {} - -pub trait CoordinateOrigin { - fn origin(&self) -> T; -} diff --git a/crates/lox-orbits/src/propagators.rs b/crates/lox-orbits/src/propagators.rs index 59fcf23d..9afd6f0a 100644 --- a/crates/lox-orbits/src/propagators.rs +++ b/crates/lox-orbits/src/propagators.rs @@ -1,7 +1,8 @@ +use lox_bodies::Origin; use lox_time::TimeLike; use crate::trajectories::TrajectoryError; -use crate::{frames::ReferenceFrame, origins::Origin, states::State, trajectories::Trajectory}; +use crate::{frames::ReferenceFrame, states::State, trajectories::Trajectory}; pub mod semi_analytical; pub mod sgp4; diff --git a/crates/lox-orbits/src/propagators/semi_analytical.rs b/crates/lox-orbits/src/propagators/semi_analytical.rs index f398b253..24ebd7ba 100644 --- a/crates/lox-orbits/src/propagators/semi_analytical.rs +++ b/crates/lox-orbits/src/propagators/semi_analytical.rs @@ -8,13 +8,12 @@ use thiserror::Error; -use lox_bodies::PointMass; +use lox_bodies::{DynOrigin, MaybePointMass, Origin, PointMass}; use lox_time::TimeLike; -use crate::frames::{CoordinateSystem, Icrf}; -use crate::origins::CoordinateOrigin; +use crate::frames::{CoordinateSystem, DynFrame, Icrf, ReferenceFrame}; use crate::propagators::{stumpff, Propagator}; -use crate::states::State; +use crate::states::{DynState, State}; use crate::trajectories::TrajectoryError; #[derive(Debug, Error, Eq, PartialEq)] @@ -26,32 +25,49 @@ pub enum ValladoError { } #[derive(Debug, Copy, Clone, PartialEq)] -pub struct Vallado { - initial_state: State, +pub struct Vallado { + initial_state: State, max_iter: i32, } -impl CoordinateOrigin for Vallado +impl CoordinateSystem for Vallado where T: TimeLike, - O: PointMass + Clone, + O: Origin, + R: ReferenceFrame + Clone, { - fn origin(&self) -> O { - self.initial_state.origin() + fn reference_frame(&self) -> R { + self.initial_state.reference_frame() } } -impl CoordinateSystem for Vallado +impl Vallado where T: TimeLike, - O: PointMass, + O: MaybePointMass + Clone, + R: ReferenceFrame, { - fn reference_frame(&self) -> Icrf { - Icrf + fn gravitational_parameter(&self) -> f64 { + self.initial_state + .origin() + .maybe_gravitational_parameter() + .expect("gravitational parameter should be available") + } + + pub fn with_max_iter(&mut self, max_iter: i32) -> &mut Self { + self.max_iter = max_iter; + self + } + + pub fn origin(&self) -> O + where + O: Clone, + { + self.initial_state.origin() } } -impl Vallado +impl Vallado where T: TimeLike, O: PointMass, @@ -62,24 +78,41 @@ where max_iter: 300, } } +} - pub fn with_max_iter(&mut self, max_iter: i32) -> &mut Self { - self.max_iter = max_iter; - self +impl Vallado +where + T: TimeLike, +{ + // TODO: Use better error type + pub fn with_dynamic(initial_state: DynState) -> Result { + if initial_state + .origin() + .maybe_gravitational_parameter() + .is_none() + || initial_state.reference_frame() != DynFrame::Icrf + { + return Err("invalid frame or origin"); + } + Ok(Self { + initial_state, + max_iter: 300, + }) } } -impl Propagator for Vallado +impl Propagator for Vallado where T: TimeLike + Clone, - O: PointMass + Clone, + O: MaybePointMass + Clone, + R: ReferenceFrame + Clone, { type Error = ValladoError; - fn propagate(&self, time: T) -> Result, Self::Error> { + fn propagate(&self, time: T) -> Result, Self::Error> { let frame = self.reference_frame(); let origin = self.origin(); - let mu = origin.gravitational_parameter(); + let mu = self.gravitational_parameter(); let t0 = self.initial_state.time(); let dt = (time.clone() - t0).to_decimal_seconds(); let sqrt_mu = mu.sqrt(); @@ -149,8 +182,7 @@ mod tests { use lox_time::utc; use lox_time::utc::Utc; - use crate::elements::{Keplerian, ToKeplerian}; - use crate::states::ToCartesian; + use crate::elements::Keplerian; use super::*; diff --git a/crates/lox-orbits/src/propagators/sgp4.rs b/crates/lox-orbits/src/propagators/sgp4.rs index f6423b3c..5b04b8b1 100644 --- a/crates/lox-orbits/src/propagators/sgp4.rs +++ b/crates/lox-orbits/src/propagators/sgp4.rs @@ -66,8 +66,6 @@ impl Propagator, Earth, Icrf> for Sgp4 { mod tests { use float_eq::assert_float_eq; - use crate::elements::ToKeplerian; - use super::*; #[test] diff --git a/crates/lox-orbits/src/python.rs b/crates/lox-orbits/src/python.rs index 08e39d03..b951f1d7 100644 --- a/crates/lox-orbits/src/python.rs +++ b/crates/lox-orbits/src/python.rs @@ -6,8 +6,6 @@ * file, you can obtain one at https://mozilla.org/MPL/2.0/. */ -use std::convert::TryFrom; - use glam::DVec3; use lox_ephem::python::PySpk; use numpy::{PyArray1, PyArray2, PyArrayMethods}; @@ -16,11 +14,11 @@ use pyo3::{ exceptions::PyValueError, pyclass, pyfunction, pymethods, types::{PyAnyMethods, PyList}, - Bound, PyAny, PyErr, PyObject, PyResult, Python, ToPyObject, + Bound, IntoPyObjectExt, PyAny, PyErr, PyResult, Python, }; +use python::PyOrigin; use sgp4::Elements; -use lox_bodies::python::PyPlanet; use lox_bodies::*; use lox_math::roots::Brent; use lox_time::deltas::TimeDelta; @@ -29,19 +27,17 @@ use lox_time::python::time_scales::PyTimeScale; use lox_time::python::ut1::{PyNoOpOffsetProvider, PyUt1Provider}; use lox_time::time_scales::Tai; use lox_time::transformations::TryToScale; -use lox_time::{python::time::PyTime, ut1::DeltaUt1Tai, Time}; -use python::PyBody; +use lox_time::{python::time::PyTime, ut1::DeltaUt1Tai}; use crate::analysis::{ElevationMask, ElevationMaskError}; -use crate::elements::{Keplerian, ToKeplerian}; +use crate::elements::{DynKeplerian, Keplerian}; use crate::events::{Event, FindEventError, Window}; -use crate::frames::{BodyFixed, CoordinateSystem, Icrf, ReferenceFrame, Topocentric, TryToFrame}; -use crate::ground::{GroundLocation, GroundPropagator, GroundPropagatorError, Observables}; -use crate::origins::CoordinateOrigin; +use crate::frames::{CoordinateSystem, DynFrame, ReferenceFrame, TryRotateTo, UnknownFrameError}; +use crate::ground::{DynGroundLocation, DynGroundPropagator, GroundPropagatorError, Observables}; use crate::propagators::semi_analytical::{Vallado, ValladoError}; use crate::propagators::sgp4::{Sgp4, Sgp4Error}; use crate::propagators::Propagator; -use crate::states::ToCartesian; +use crate::states::DynState; use crate::trajectories::TrajectoryTransformationError; use crate::{ frames::FrameTransformationProvider, @@ -49,8 +45,6 @@ use crate::{ trajectories::{Trajectory, TrajectoryError}, }; -mod generated; - impl From for PyErr { fn from(err: TrajectoryTransformationError) -> Self { // FIXME: wrong error type @@ -76,7 +70,7 @@ pub fn find_events( Ok(crate::events::find_events( |t| { func.call((t,), None) - .unwrap_or(f64::NAN.to_object(py).into_bound(py)) + .unwrap_or(f64::NAN.into_bound_py_any(py).unwrap()) .extract() .unwrap_or(f64::NAN) }, @@ -101,7 +95,7 @@ pub fn find_windows( Ok(crate::events::find_windows( |t| { func.call((t,), None) - .unwrap_or(f64::NAN.to_object(py).into_bound(py)) + .unwrap_or(f64::NAN.into_bound_py_any(py).unwrap()) .extract() .unwrap_or(f64::NAN) }, @@ -115,198 +109,22 @@ pub fn find_windows( .collect()) } +impl From for PyErr { + fn from(err: UnknownFrameError) -> Self { + PyValueError::new_err(err.to_string()) + } +} + #[pyclass(name = "Frame", module = "lox_space", frozen)] #[pyo3(eq)] -#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd)] -pub enum PyFrame { - Icrf, - Sun, - Mercury, - Venus, - Earth, - Mars, - Jupiter, - Saturn, - Uranus, - Neptune, - Pluto, - Moon, - Phobos, - Deimos, - Io, - Europa, - Ganymede, - Callisto, - Amalthea, - Himalia, - Elara, - Pasiphae, - Sinope, - Lysithea, - Carme, - Ananke, - Leda, - Thebe, - Adrastea, - Metis, - Callirrhoe, - Themisto, - Magaclite, - Taygete, - Chaldene, - Harpalyke, - Kalyke, - Iocaste, - Erinome, - Isonoe, - Praxidike, - Autonoe, - Thyone, - Hermippe, - Aitne, - Eurydome, - Euanthe, - Euporie, - Orthosie, - Sponde, - Kale, - Pasithee, - Hegemone, - Mneme, - Aoede, - Thelxinoe, - Arche, - Kallichore, - Helike, - Carpo, - Eukelade, - Cyllene, - Kore, - Herse, - Dia, - Mimas, - Enceladus, - Tethys, - Dione, - Rhea, - Titan, - Hyperion, - Iapetus, - Phoebe, - Janus, - Epimetheus, - Helene, - Telesto, - Calypso, - Atlas, - Prometheus, - Pandora, - Pan, - Ymir, - Paaliaq, - Tarvos, - Ijiraq, - Suttungr, - Kiviuq, - Mundilfari, - Albiorix, - Skathi, - Erriapus, - Siarnaq, - Thrymr, - Narvi, - Methone, - Pallene, - Polydeuces, - Daphnis, - Aegir, - Bebhionn, - Bergelmir, - Bestla, - Farbauti, - Fenrir, - Fornjot, - Hati, - Hyrrokkin, - Kari, - Loge, - Skoll, - Surtur, - Anthe, - Jarnsaxa, - Greip, - Tarqeq, - Aegaeon, - Ariel, - Umbriel, - Titania, - Oberon, - Miranda, - Cordelia, - Ophelia, - Bianca, - Cressida, - Desdemona, - Juliet, - Portia, - Rosalind, - Belinda, - Puck, - Caliban, - Sycorax, - Prospero, - Setebos, - Stephano, - Trinculo, - Francisco, - Margaret, - Ferdinand, - Perdita, - Mab, - Cupid, - Triton, - Nereid, - Naiad, - Thalassa, - Despina, - Galatea, - Larissa, - Proteus, - Halimede, - Psamathe, - Sao, - Laomedeia, - Neso, - Charon, - Nix, - Hydra, - Kerberos, - Styx, - Gaspra, - Ida, - Dactyl, - Ceres, - Pallas, - Vesta, - Psyche, - Lutetia, - Kleopatra, - Eros, - Davida, - Mathilde, - Steins, - Braille, - WilsonHarrington, - Toutatis, - Itokawa, - Bennu, -} +#[derive(Debug, Clone, Default, Eq, PartialEq, Ord, PartialOrd)] +pub struct PyFrame(DynFrame); #[pymethods] impl PyFrame { #[new] fn new(abbreviation: &str) -> PyResult { - abbreviation.parse() + Ok(Self(abbreviation.parse()?)) } fn __getnewargs__(&self) -> (String,) { @@ -314,11 +132,11 @@ impl PyFrame { } fn name(&self) -> String { - ReferenceFrame::name(self) + self.0.name() } fn abbreviation(&self) -> String { - ReferenceFrame::abbreviation(self) + self.0.abbreviation() } } @@ -330,7 +148,7 @@ impl FrameTransformationProvider for PyUt1Provider {} #[pyclass(name = "State", module = "lox_space", frozen)] #[derive(Debug, Clone)] -pub struct PyState(pub State); +pub struct PyState(pub State); #[pymethods] impl PyState { @@ -340,22 +158,18 @@ impl PyState { time: PyTime, position: (f64, f64, f64), velocity: (f64, f64, f64), - origin: Option<&Bound<'_, PyAny>>, + origin: Option, frame: Option, ) -> PyResult { - let origin: PyBody = if let Some(origin) = origin { - PyBody::try_from(origin)? - } else { - PyBody::Planet(PyPlanet::new("Earth").unwrap()) - }; - let frame = frame.unwrap_or(PyFrame::Icrf); + let origin = origin.unwrap_or_default(); + let frame = frame.unwrap_or_default(); Ok(PyState(State::new( time, DVec3::new(position.0, position.1, position.2), DVec3::new(velocity.0, velocity.1, velocity.2), - origin, - frame, + origin.0, + frame.0, ))) } @@ -363,22 +177,22 @@ impl PyState { self.0.time().clone() } - fn origin(&self) -> PyObject { - self.0.origin().into() + fn origin(&self) -> PyOrigin { + PyOrigin(self.0.origin()) } fn reference_frame(&self) -> PyFrame { - self.0.reference_frame() + PyFrame(self.0.reference_frame()) } fn position<'py>(&self, py: Python<'py>) -> Bound<'py, PyArray1> { let pos = self.0.position().to_array(); - PyArray1::from_slice_bound(py, &pos) + PyArray1::from_slice(py, &pos) } fn velocity<'py>(&self, py: Python<'py>) -> Bound<'py, PyArray1> { let vel = self.0.velocity().to_array(); - PyArray1::from_slice_bound(py, &vel) + PyArray1::from_slice(py, &vel) } #[pyo3(signature = (frame, provider=None))] @@ -387,70 +201,77 @@ impl PyState { frame: PyFrame, provider: Option<&Bound<'_, PyUt1Provider>>, ) -> PyResult { - self.to_frame_generated(frame, provider) + let rot = match provider { + Some(provider) => { + self.0 + .reference_frame() + .try_rotation(&frame.0, self.0.time(), provider.get()) + } + None => self.0.reference_frame().try_rotation( + &frame.0, + self.0.time(), + &PyNoOpOffsetProvider, + ), + } + .map_err(|err| PyValueError::new_err(err.to_string()))?; + let (r1, v1) = rot.rotate_state(self.0.position(), self.0.velocity()); + Ok(PyState(State::new( + self.time(), + r1, + v1, + self.0.origin(), + frame.0, + ))) } - fn to_origin(&self, target: &Bound<'_, PyAny>, ephemeris: &Bound<'_, PySpk>) -> PyResult { - if self.0.reference_frame() != PyFrame::Icrf { - return Err(PyValueError::new_err( - "only inertial frames are supported for conversion to Keplerian elements", - )); - } - let target = PyBody::try_from(target)?; + fn to_origin(&self, target: PyOrigin, ephemeris: &Bound<'_, PySpk>) -> PyResult { + let frame = self.reference_frame(); + let s = if frame.0 != DynFrame::Icrf { + self.to_frame(PyFrame(DynFrame::Icrf), None)? + } else { + self.clone() + }; let spk = &ephemeris.borrow().0; - let s1 = self - .0 - .with_frame(Icrf) - .to_origin(target, spk)? - .with_frame(PyFrame::Icrf); - Ok(Self(s1)) + let mut s1 = Self(s.0.to_origin_dynamic(target.0, spk)?); + if frame.0 != DynFrame::Icrf { + s1 = s1.to_frame(frame, None)? + } + Ok(s1) } fn to_keplerian(&self) -> PyResult { - if self.0.reference_frame() != PyFrame::Icrf { + if self.0.reference_frame() != DynFrame::Icrf { return Err(PyValueError::new_err( "only inertial frames are supported for conversion to Keplerian elements", )); } - Ok(PyKeplerian(self.0.to_keplerian())) + Ok(PyKeplerian( + self.0.try_to_keplerian().map_err(PyValueError::new_err)?, + )) } fn rotation_lvlh<'py>(&self, py: Python<'py>) -> PyResult>> { - if self.reference_frame() != PyFrame::Icrf { + if self.0.reference_frame() != DynFrame::Icrf { return Err(PyValueError::new_err( "only inertial frames are supported for the LVLH rotation matrix", )); } - let rot = self.0.with_frame(Icrf).rotation_lvlh(); + let rot = self.0.try_rotation_lvlh().map_err(PyValueError::new_err)?; let rot: Vec> = rot.to_cols_array_2d().iter().map(|v| v.to_vec()).collect(); - Ok(PyArray2::from_vec2_bound(py, &rot)?) + Ok(PyArray2::from_vec2(py, &rot)?) } - fn to_ground_location(&self, py: Python<'_>) -> PyResult { - if self.reference_frame() != PyFrame::Icrf { - return Err(PyValueError::new_err( - "only inertial frames are supported for the ground location transformations", - )); - } - let origin: PyPlanet = self.origin().extract(py)?; - if origin.name() != "Earth" { - return Err(PyValueError::new_err( - "only Earth-based frames are supported for the ground location transformations", - )); - } + fn to_ground_location(&self) -> PyResult { Ok(PyGroundLocation( self.0 - .with_origin_and_frame(Earth, Icrf) - .try_to_frame(BodyFixed(Earth), &PyNoOpOffsetProvider)? - .to_ground_location() - .map_err(|err| PyValueError::new_err(err.to_string()))? - .with_body(origin), + .to_dyn_ground_location() + .map_err(|err| PyValueError::new_err(err.to_string()))?, )) } } #[pyclass(name = "Keplerian", module = "lox_space", frozen)] -pub struct PyKeplerian(pub Keplerian); +pub struct PyKeplerian(pub DynKeplerian); #[pymethods] impl PyKeplerian { @@ -474,27 +295,30 @@ impl PyKeplerian { longitude_of_ascending_node: f64, argument_of_periapsis: f64, true_anomaly: f64, - origin: Option<&Bound<'_, PyAny>>, + origin: Option, ) -> PyResult { - let origin: PyBody = origin.try_into()?; - Ok(PyKeplerian(Keplerian::new( - time, - origin, - semi_major_axis, - eccentricity, - inclination, - longitude_of_ascending_node, - argument_of_periapsis, - true_anomaly, - ))) + let origin = origin.map(|origin| origin.0).unwrap_or_default(); + Ok(PyKeplerian( + Keplerian::with_dynamic( + time, + origin, + semi_major_axis, + eccentricity, + inclination, + longitude_of_ascending_node, + argument_of_periapsis, + true_anomaly, + ) + .map_err(|err| PyValueError::new_err(err.to_string()))?, + )) } fn time(&self) -> PyTime { self.0.time() } - fn origin(&self) -> PyObject { - self.0.origin().into() + fn origin(&self) -> PyOrigin { + PyOrigin(self.0.origin()) } fn semi_major_axis(&self) -> f64 { @@ -522,7 +346,7 @@ impl PyKeplerian { } fn to_cartesian(&self) -> PyResult { - Ok(PyState(self.0.to_cartesian().with_frame(PyFrame::Icrf))) + Ok(PyState(self.0.to_cartesian())) } fn orbital_period(&self) -> PyTimeDelta { @@ -532,7 +356,7 @@ impl PyKeplerian { #[pyclass(name = "Trajectory", module = "lox_space", frozen)] #[derive(Debug, Clone)] -pub struct PyTrajectory(pub Trajectory); +pub struct PyTrajectory(pub Trajectory); impl From for PyErr { fn from(err: TrajectoryError) -> Self { @@ -545,7 +369,7 @@ impl PyTrajectory { #[new] fn new(states: &Bound<'_, PyList>) -> PyResult { let states: Vec = states.extract()?; - let states: Vec> = states.into_iter().map(|s| s.0).collect(); + let states: Vec> = states.into_iter().map(|s| s.0).collect(); Ok(PyTrajectory(Trajectory::new(&states)?)) } @@ -555,45 +379,35 @@ impl PyTrajectory { _cls: &Bound<'_, PyType>, start_time: PyTime, array: &Bound<'_, PyArray2>, - origin: Option<&Bound<'_, PyAny>>, + origin: Option, frame: Option, ) -> PyResult { - let origin: PyBody = if let Some(origin) = origin { - PyBody::try_from(origin)? - } else { - PyBody::Planet(PyPlanet::new("Earth").unwrap()) - }; - let frame = frame.unwrap_or(PyFrame::Icrf); + let origin = origin.unwrap_or_default(); + let frame = frame.unwrap_or_default(); let array = array.to_owned_array(); if array.ncols() != 7 { return Err(PyValueError::new_err("invalid shape")); } - let mut states: Vec> = Vec::with_capacity(array.nrows()); + let mut states: Vec> = Vec::with_capacity(array.nrows()); for row in array.rows() { - let time = PyTime(start_time.0 + TimeDelta::from_decimal_seconds(row[0]).unwrap()); + let time = PyTime(start_time.0 + TimeDelta::from_decimal_seconds(row[0])?); let position = DVec3::new(row[1], row[2], row[3]); let velocity = DVec3::new(row[4], row[5], row[6]); - states.push(State::new( - time, - position, - velocity, - origin.clone(), - frame.clone(), - )); + states.push(State::new(time, position, velocity, origin.0, frame.0)); } Ok(PyTrajectory(Trajectory::new(&states)?)) } - fn origin(&self) -> PyObject { - self.0.origin().into() + fn origin(&self) -> PyOrigin { + PyOrigin(self.0.origin()) } fn reference_frame(&self) -> PyFrame { - self.0.reference_frame() + PyFrame(self.0.reference_frame()) } fn to_numpy<'py>(&self, py: Python<'py>) -> PyResult>> { - Ok(PyArray2::from_vec2_bound(py, &self.0.to_vec())?) + Ok(PyArray2::from_vec2(py, &self.0.to_vec())?) } fn states(&self) -> Vec { @@ -606,7 +420,7 @@ impl PyTrajectory { .find_events(|s| { func.call((PyState(s),), None) // FIXME: Bad idea - .unwrap_or(f64::NAN.to_object(py).into_bound(py)) + .unwrap_or(f64::NAN.into_bound_py_any(py).unwrap()) .extract() .unwrap_or(f64::NAN) }) @@ -621,7 +435,7 @@ impl PyTrajectory { .find_windows(|s| { func.call((PyState(s),), None) // FIXME: Bad idea - .unwrap_or(f64::NAN.to_object(py).into_bound(py)) + .unwrap_or(f64::NAN.into_bound_py_any(py).unwrap()) .extract() .unwrap_or(f64::NAN) }) @@ -646,24 +460,20 @@ impl PyTrajectory { frame: PyFrame, provider: Option<&Bound<'_, PyUt1Provider>>, ) -> PyResult { - let mut states: Vec> = - Vec::with_capacity(self.0.states().len()); + let mut states: Vec> = Vec::with_capacity(self.0.states().len()); for s in self.0.states() { states.push(PyState(s).to_frame(frame.clone(), provider)?.0); } Ok(PyTrajectory(Trajectory::new(&states)?)) } - fn to_origin(&self, target: &Bound<'_, PyAny>, ephemeris: &Bound<'_, PySpk>) -> PyResult { - let target = PyBody::try_from(target)?; - let spk = &ephemeris.borrow().0; - let s1 = self - .0 - .clone() - .with_frame(Icrf) - .to_origin(target, spk)? - .with_frame(PyFrame::Icrf); - Ok(Self(s1)) + fn to_origin(&self, target: PyOrigin, ephemeris: &Bound<'_, PySpk>) -> PyResult { + let mut states: Vec = Vec::with_capacity(self.states().len()); + for s in self.states() { + states.push(s.to_origin(target.clone(), ephemeris)?) + } + let states: Vec> = states.into_iter().map(|s| s.0).collect(); + Ok(Self(Trajectory::new(&states)?)) } } @@ -719,7 +529,7 @@ impl PyWindow { } #[pyclass(name = "Vallado", module = "lox_space", frozen)] -pub struct PyVallado(pub Vallado); +pub struct PyVallado(pub Vallado); impl From for PyErr { fn from(err: ValladoError) -> Self { @@ -733,12 +543,9 @@ impl PyVallado { #[new] #[pyo3(signature =(initial_state, max_iter=None))] fn new(initial_state: PyState, max_iter: Option) -> PyResult { - if initial_state.0.reference_frame() != PyFrame::Icrf { - return Err(PyValueError::new_err( - "only inertial frames are supported for the Vallado propagator", - )); - } - let mut vallado = Vallado::new(initial_state.0.with_frame(Icrf)); + let mut vallado = Vallado::with_dynamic(initial_state.0).map_err(|_| { + PyValueError::new_err("only inertial frames are supported for the Vallado propagator") + })?; if let Some(max_iter) = max_iter { vallado.with_max_iter(max_iter); } @@ -751,18 +558,10 @@ impl PyVallado { steps: &Bound<'py, PyAny>, ) -> PyResult> { if let Ok(time) = steps.extract::() { - return Ok(Bound::new( - py, - PyState(self.0.propagate(time)?.with_frame(PyFrame::Icrf)), - )? - .into_any()); + return Ok(Bound::new(py, PyState(self.0.propagate(time)?))?.into_any()); } if let Ok(steps) = steps.extract::>() { - return Ok(Bound::new( - py, - PyTrajectory(self.0.propagate_all(steps)?.with_frame(PyFrame::Icrf)), - )? - .into_any()); + return Ok(Bound::new(py, PyTrajectory(self.0.propagate_all(steps)?))?.into_any()); } Err(PyValueError::new_err("invalid time delta(s)")) } @@ -770,23 +569,27 @@ impl PyVallado { #[pyclass(name = "GroundLocation", module = "lox_space", frozen)] #[derive(Clone)] -pub struct PyGroundLocation(pub GroundLocation); +pub struct PyGroundLocation(pub DynGroundLocation); #[pymethods] impl PyGroundLocation { #[new] - fn new(planet: PyPlanet, longitude: f64, latitude: f64, altitude: f64) -> Self { - PyGroundLocation(GroundLocation::new(longitude, latitude, altitude, planet)) + fn new(origin: PyOrigin, longitude: f64, latitude: f64, altitude: f64) -> PyResult { + Ok(PyGroundLocation( + DynGroundLocation::with_dynamic(longitude, latitude, altitude, origin.0) + .map_err(PyValueError::new_err)?, + )) } - #[pyo3(signature = (state, provider=None))] + #[pyo3(signature = (state, provider=None, frame=None))] fn observables( &self, state: PyState, provider: Option<&Bound<'_, PyUt1Provider>>, + frame: Option, ) -> PyResult { - // FIXME - let state = state.to_frame(PyFrame::Earth, provider)?; + let frame = frame.unwrap_or(PyFrame(DynFrame::BodyFixed(state.0.origin()))); + let state = state.to_frame(frame, provider)?; let rot = self.0.rotation_to_topocentric(); let position = rot * (state.0.position() - self.0.body_fixed_position()); let velocity = rot * state.0.velocity(); @@ -802,7 +605,7 @@ impl PyGroundLocation { fn rotation_to_topocentric<'py>(&self, py: Python<'py>) -> PyResult>> { let rot = self.0.rotation_to_topocentric(); let rot: Vec> = rot.to_cols_array_2d().iter().map(|v| v.to_vec()).collect(); - Ok(PyArray2::from_vec2_bound(py, &rot)?) + Ok(PyArray2::from_vec2(py, &rot)?) } fn longitude(&self) -> f64 { @@ -819,7 +622,7 @@ impl PyGroundLocation { } #[pyclass(name = "GroundPropagator", module = "lox_space", frozen)] -pub struct PyGroundPropagator(GroundPropagator); +pub struct PyGroundPropagator(DynGroundPropagator); impl From for PyErr { fn from(err: GroundPropagatorError) -> Self { @@ -831,7 +634,7 @@ impl From for PyErr { impl PyGroundPropagator { #[new] fn new(location: PyGroundLocation, provider: PyUt1Provider) -> Self { - PyGroundPropagator(GroundPropagator::new(location.0, provider)) + PyGroundPropagator(DynGroundPropagator::with_dynamic(location.0, provider)) } fn propagate<'py>( @@ -840,27 +643,10 @@ impl PyGroundPropagator { steps: &Bound<'py, PyAny>, ) -> PyResult> { if let Ok(time) = steps.extract::() { - return Ok(Bound::new( - py, - PyState( - self.0 - .propagate(time)? - .with_origin_and_frame(PyBody::Planet(self.0.origin()), PyFrame::Icrf), - ), - )? - .into_any()); + return Ok(Bound::new(py, PyState(self.0.propagate_dyn(time)?))?.into_any()); } if let Ok(steps) = steps.extract::>() { - return Ok(Bound::new( - py, - PyTrajectory( - self.0 - .propagate_all(steps)? - .with_frame(PyFrame::Icrf) - .with_origin_and_frame(PyBody::Planet(self.0.origin()), PyFrame::Icrf), - ), - )? - .into_any()); + return Ok(Bound::new(py, PyTrajectory(self.0.propagate_all_dyn(steps)?))?.into_any()); } Err(PyValueError::new_err("invalid time delta(s)")) } @@ -921,42 +707,29 @@ impl PySgp4 { pytime, s1.position(), s1.velocity(), - PyBody::Planet(PyPlanet::new("Earth").unwrap()), - PyFrame::Icrf, + DynOrigin::default(), + DynFrame::default(), )), )? .into_any()); } if let Ok(pysteps) = steps.extract::>() { - let mut steps: Vec> = Vec::with_capacity(pysteps.len()); + let mut states: Vec> = Vec::with_capacity(pysteps.len()); for step in pysteps { let time = match provider { None => step.try_to_scale(Tai, &PyNoOpOffsetProvider)?, Some(provider) => step.try_to_scale(Tai, provider.get())?, }; - steps.push(time); - } - let trajectory = self - .0 - .propagate_all(steps)? - .with_frame(PyFrame::Icrf) - .with_origin_and_frame( - PyBody::Planet(PyPlanet::new("Earth").unwrap()), - PyFrame::Icrf, + let s = self.0.propagate(time)?; + let s = State::new( + step, + s.position(), + s.velocity(), + DynOrigin::default(), + DynFrame::default(), ); - let states: Vec> = trajectory - .states() - .iter() - .map(|s| { - State::new( - PyTime(s.time().with_scale(PyTimeScale::Tai)), - s.position(), - s.velocity(), - s.origin(), - s.reference_frame(), - ) - }) - .collect(); + states.push(s); + } return Ok(Bound::new(py, PyTrajectory(Trajectory::new(&states)?))?.into_any()); } Err(PyValueError::new_err("invalid time delta(s)")) @@ -977,16 +750,11 @@ pub fn visibility( "ground station and spacecraft must have the same origin", )); } - let sc_origin = match sc.0.origin() { - PyBody::Planet(planet) => planet, - _ => return Err(PyValueError::new_err("invalid origin")), - }; let times: Vec = times.extract()?; let provider = provider.get(); let mask = &mask.borrow().0; - let sc = sc.0.with_origin_and_frame(sc_origin, Icrf); Ok( - crate::analysis::visibility(×, &gs.0, mask, &sc, provider) + crate::analysis::visibility_dyn(×, &gs.0, mask, &sc.0, provider) .into_iter() .map(PyWindow) .collect(), @@ -1067,49 +835,6 @@ impl PyElevationMask { } } -#[pyclass(name = "Topocentric", module = "lox_space", frozen)] -pub struct PyTopocentric(pub Topocentric); - -#[pymethods] -impl PyTopocentric { - #[new] - fn new(location: PyGroundLocation) -> Self { - PyTopocentric(Topocentric::new(location.0)) - } -} - -#[pyfunction] -pub fn elevation( - time: PyTime, - frame: &Bound<'_, PyTopocentric>, - gs: &Bound<'_, PyTrajectory>, - sc: &Bound<'_, PyTrajectory>, - provider: &Bound<'_, PyUt1Provider>, -) -> f64 { - let gs = gs.get(); - let sc = sc.get(); - let frame = frame.get(); - // FIXME - if gs.0.reference_frame() != PyFrame::Icrf || sc.0.reference_frame() != PyFrame::Icrf { - return f64::NAN; - } - if gs.0.origin().name() != sc.0.origin().name() { - return f64::NAN; - } - let gs_origin = match gs.0.origin() { - PyBody::Planet(planet) => planet, - _ => return f64::NAN, - }; - let sc_origin = match sc.0.origin() { - PyBody::Planet(planet) => planet, - _ => return f64::NAN, - }; - let provider = provider.get(); - let gs = gs.0.with_origin_and_frame(gs_origin, Icrf); - let sc = sc.0.with_origin_and_frame(sc_origin, Icrf); - crate::analysis::elevation(time, &frame.0, &gs, &sc, provider) -} - #[pyclass(name = "Observables", module = "lox_space", frozen)] pub struct PyObservables(pub Observables); diff --git a/crates/lox-orbits/src/python/.gitkeep b/crates/lox-orbits/src/python/.gitkeep deleted file mode 100644 index e69de29b..00000000 diff --git a/crates/lox-orbits/src/python/generated.rs b/crates/lox-orbits/src/python/generated.rs deleted file mode 100644 index f1e43232..00000000 --- a/crates/lox-orbits/src/python/generated.rs +++ /dev/null @@ -1,7814 +0,0 @@ -/* - * 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::frames::{ - BodyFixed, CoordinateSystem, FrameTransformationProvider, Icrf, ReferenceFrame, TryToFrame, -}; -use crate::python::{PyFrame, PyState}; -use crate::states::State; -use lox_bodies::python::PyBody; -use lox_bodies::*; -use lox_time::python::time::PyTime; -use lox_time::python::ut1::{PyDeltaUt1Provider, PyNoOpOffsetProvider, PyUt1Provider}; -use pyo3::exceptions::PyValueError; -use pyo3::{Bound, PyErr, PyResult}; -use std::str::FromStr; -impl TryToFrame for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State; - type Error = T::Error; - fn try_to_frame( - &self, - frame: Icrf, - provider: &T, - ) -> Result, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => Ok(self.0.with_frame(frame)), - PyFrame::Sun => self - .0 - .with_frame(BodyFixed(Sun)) - .try_to_frame(frame, provider), - PyFrame::Mercury => self - .0 - .with_frame(BodyFixed(Mercury)) - .try_to_frame(frame, provider), - PyFrame::Venus => self - .0 - .with_frame(BodyFixed(Venus)) - .try_to_frame(frame, provider), - PyFrame::Earth => self - .0 - .with_frame(BodyFixed(Earth)) - .try_to_frame(frame, provider), - PyFrame::Mars => self - .0 - .with_frame(BodyFixed(Mars)) - .try_to_frame(frame, provider), - PyFrame::Jupiter => self - .0 - .with_frame(BodyFixed(Jupiter)) - .try_to_frame(frame, provider), - PyFrame::Saturn => self - .0 - .with_frame(BodyFixed(Saturn)) - .try_to_frame(frame, provider), - PyFrame::Uranus => self - .0 - .with_frame(BodyFixed(Uranus)) - .try_to_frame(frame, provider), - PyFrame::Neptune => self - .0 - .with_frame(BodyFixed(Neptune)) - .try_to_frame(frame, provider), - PyFrame::Pluto => self - .0 - .with_frame(BodyFixed(Pluto)) - .try_to_frame(frame, provider), - PyFrame::Moon => self - .0 - .with_frame(BodyFixed(Moon)) - .try_to_frame(frame, provider), - PyFrame::Phobos => self - .0 - .with_frame(BodyFixed(Phobos)) - .try_to_frame(frame, provider), - PyFrame::Deimos => self - .0 - .with_frame(BodyFixed(Deimos)) - .try_to_frame(frame, provider), - PyFrame::Io => self - .0 - .with_frame(BodyFixed(Io)) - .try_to_frame(frame, provider), - PyFrame::Europa => self - .0 - .with_frame(BodyFixed(Europa)) - .try_to_frame(frame, provider), - PyFrame::Ganymede => self - .0 - .with_frame(BodyFixed(Ganymede)) - .try_to_frame(frame, provider), - PyFrame::Callisto => self - .0 - .with_frame(BodyFixed(Callisto)) - .try_to_frame(frame, provider), - PyFrame::Amalthea => self - .0 - .with_frame(BodyFixed(Amalthea)) - .try_to_frame(frame, provider), - PyFrame::Himalia => self - .0 - .with_frame(BodyFixed(Himalia)) - .try_to_frame(frame, provider), - PyFrame::Elara => self - .0 - .with_frame(BodyFixed(Elara)) - .try_to_frame(frame, provider), - PyFrame::Pasiphae => self - .0 - .with_frame(BodyFixed(Pasiphae)) - .try_to_frame(frame, provider), - PyFrame::Sinope => self - .0 - .with_frame(BodyFixed(Sinope)) - .try_to_frame(frame, provider), - PyFrame::Lysithea => self - .0 - .with_frame(BodyFixed(Lysithea)) - .try_to_frame(frame, provider), - PyFrame::Carme => self - .0 - .with_frame(BodyFixed(Carme)) - .try_to_frame(frame, provider), - PyFrame::Ananke => self - .0 - .with_frame(BodyFixed(Ananke)) - .try_to_frame(frame, provider), - PyFrame::Leda => self - .0 - .with_frame(BodyFixed(Leda)) - .try_to_frame(frame, provider), - PyFrame::Thebe => self - .0 - .with_frame(BodyFixed(Thebe)) - .try_to_frame(frame, provider), - PyFrame::Adrastea => self - .0 - .with_frame(BodyFixed(Adrastea)) - .try_to_frame(frame, provider), - PyFrame::Metis => self - .0 - .with_frame(BodyFixed(Metis)) - .try_to_frame(frame, provider), - PyFrame::Callirrhoe => self - .0 - .with_frame(BodyFixed(Callirrhoe)) - .try_to_frame(frame, provider), - PyFrame::Themisto => self - .0 - .with_frame(BodyFixed(Themisto)) - .try_to_frame(frame, provider), - PyFrame::Magaclite => self - .0 - .with_frame(BodyFixed(Magaclite)) - .try_to_frame(frame, provider), - PyFrame::Taygete => self - .0 - .with_frame(BodyFixed(Taygete)) - .try_to_frame(frame, provider), - PyFrame::Chaldene => self - .0 - .with_frame(BodyFixed(Chaldene)) - .try_to_frame(frame, provider), - PyFrame::Harpalyke => self - .0 - .with_frame(BodyFixed(Harpalyke)) - .try_to_frame(frame, provider), - PyFrame::Kalyke => self - .0 - .with_frame(BodyFixed(Kalyke)) - .try_to_frame(frame, provider), - PyFrame::Iocaste => self - .0 - .with_frame(BodyFixed(Iocaste)) - .try_to_frame(frame, provider), - PyFrame::Erinome => self - .0 - .with_frame(BodyFixed(Erinome)) - .try_to_frame(frame, provider), - PyFrame::Isonoe => self - .0 - .with_frame(BodyFixed(Isonoe)) - .try_to_frame(frame, provider), - PyFrame::Praxidike => self - .0 - .with_frame(BodyFixed(Praxidike)) - .try_to_frame(frame, provider), - PyFrame::Autonoe => self - .0 - .with_frame(BodyFixed(Autonoe)) - .try_to_frame(frame, provider), - PyFrame::Thyone => self - .0 - .with_frame(BodyFixed(Thyone)) - .try_to_frame(frame, provider), - PyFrame::Hermippe => self - .0 - .with_frame(BodyFixed(Hermippe)) - .try_to_frame(frame, provider), - PyFrame::Aitne => self - .0 - .with_frame(BodyFixed(Aitne)) - .try_to_frame(frame, provider), - PyFrame::Eurydome => self - .0 - .with_frame(BodyFixed(Eurydome)) - .try_to_frame(frame, provider), - PyFrame::Euanthe => self - .0 - .with_frame(BodyFixed(Euanthe)) - .try_to_frame(frame, provider), - PyFrame::Euporie => self - .0 - .with_frame(BodyFixed(Euporie)) - .try_to_frame(frame, provider), - PyFrame::Orthosie => self - .0 - .with_frame(BodyFixed(Orthosie)) - .try_to_frame(frame, provider), - PyFrame::Sponde => self - .0 - .with_frame(BodyFixed(Sponde)) - .try_to_frame(frame, provider), - PyFrame::Kale => self - .0 - .with_frame(BodyFixed(Kale)) - .try_to_frame(frame, provider), - PyFrame::Pasithee => self - .0 - .with_frame(BodyFixed(Pasithee)) - .try_to_frame(frame, provider), - PyFrame::Hegemone => self - .0 - .with_frame(BodyFixed(Hegemone)) - .try_to_frame(frame, provider), - PyFrame::Mneme => self - .0 - .with_frame(BodyFixed(Mneme)) - .try_to_frame(frame, provider), - PyFrame::Aoede => self - .0 - .with_frame(BodyFixed(Aoede)) - .try_to_frame(frame, provider), - PyFrame::Thelxinoe => self - .0 - .with_frame(BodyFixed(Thelxinoe)) - .try_to_frame(frame, provider), - PyFrame::Arche => self - .0 - .with_frame(BodyFixed(Arche)) - .try_to_frame(frame, provider), - PyFrame::Kallichore => self - .0 - .with_frame(BodyFixed(Kallichore)) - .try_to_frame(frame, provider), - PyFrame::Helike => self - .0 - .with_frame(BodyFixed(Helike)) - .try_to_frame(frame, provider), - PyFrame::Carpo => self - .0 - .with_frame(BodyFixed(Carpo)) - .try_to_frame(frame, provider), - PyFrame::Eukelade => self - .0 - .with_frame(BodyFixed(Eukelade)) - .try_to_frame(frame, provider), - PyFrame::Cyllene => self - .0 - .with_frame(BodyFixed(Cyllene)) - .try_to_frame(frame, provider), - PyFrame::Kore => self - .0 - .with_frame(BodyFixed(Kore)) - .try_to_frame(frame, provider), - PyFrame::Herse => self - .0 - .with_frame(BodyFixed(Herse)) - .try_to_frame(frame, provider), - PyFrame::Dia => self - .0 - .with_frame(BodyFixed(Dia)) - .try_to_frame(frame, provider), - PyFrame::Mimas => self - .0 - .with_frame(BodyFixed(Mimas)) - .try_to_frame(frame, provider), - PyFrame::Enceladus => self - .0 - .with_frame(BodyFixed(Enceladus)) - .try_to_frame(frame, provider), - PyFrame::Tethys => self - .0 - .with_frame(BodyFixed(Tethys)) - .try_to_frame(frame, provider), - PyFrame::Dione => self - .0 - .with_frame(BodyFixed(Dione)) - .try_to_frame(frame, provider), - PyFrame::Rhea => self - .0 - .with_frame(BodyFixed(Rhea)) - .try_to_frame(frame, provider), - PyFrame::Titan => self - .0 - .with_frame(BodyFixed(Titan)) - .try_to_frame(frame, provider), - PyFrame::Hyperion => self - .0 - .with_frame(BodyFixed(Hyperion)) - .try_to_frame(frame, provider), - PyFrame::Iapetus => self - .0 - .with_frame(BodyFixed(Iapetus)) - .try_to_frame(frame, provider), - PyFrame::Phoebe => self - .0 - .with_frame(BodyFixed(Phoebe)) - .try_to_frame(frame, provider), - PyFrame::Janus => self - .0 - .with_frame(BodyFixed(Janus)) - .try_to_frame(frame, provider), - PyFrame::Epimetheus => self - .0 - .with_frame(BodyFixed(Epimetheus)) - .try_to_frame(frame, provider), - PyFrame::Helene => self - .0 - .with_frame(BodyFixed(Helene)) - .try_to_frame(frame, provider), - PyFrame::Telesto => self - .0 - .with_frame(BodyFixed(Telesto)) - .try_to_frame(frame, provider), - PyFrame::Calypso => self - .0 - .with_frame(BodyFixed(Calypso)) - .try_to_frame(frame, provider), - PyFrame::Atlas => self - .0 - .with_frame(BodyFixed(Atlas)) - .try_to_frame(frame, provider), - PyFrame::Prometheus => self - .0 - .with_frame(BodyFixed(Prometheus)) - .try_to_frame(frame, provider), - PyFrame::Pandora => self - .0 - .with_frame(BodyFixed(Pandora)) - .try_to_frame(frame, provider), - PyFrame::Pan => self - .0 - .with_frame(BodyFixed(Pan)) - .try_to_frame(frame, provider), - PyFrame::Ymir => self - .0 - .with_frame(BodyFixed(Ymir)) - .try_to_frame(frame, provider), - PyFrame::Paaliaq => self - .0 - .with_frame(BodyFixed(Paaliaq)) - .try_to_frame(frame, provider), - PyFrame::Tarvos => self - .0 - .with_frame(BodyFixed(Tarvos)) - .try_to_frame(frame, provider), - PyFrame::Ijiraq => self - .0 - .with_frame(BodyFixed(Ijiraq)) - .try_to_frame(frame, provider), - PyFrame::Suttungr => self - .0 - .with_frame(BodyFixed(Suttungr)) - .try_to_frame(frame, provider), - PyFrame::Kiviuq => self - .0 - .with_frame(BodyFixed(Kiviuq)) - .try_to_frame(frame, provider), - PyFrame::Mundilfari => self - .0 - .with_frame(BodyFixed(Mundilfari)) - .try_to_frame(frame, provider), - PyFrame::Albiorix => self - .0 - .with_frame(BodyFixed(Albiorix)) - .try_to_frame(frame, provider), - PyFrame::Skathi => self - .0 - .with_frame(BodyFixed(Skathi)) - .try_to_frame(frame, provider), - PyFrame::Erriapus => self - .0 - .with_frame(BodyFixed(Erriapus)) - .try_to_frame(frame, provider), - PyFrame::Siarnaq => self - .0 - .with_frame(BodyFixed(Siarnaq)) - .try_to_frame(frame, provider), - PyFrame::Thrymr => self - .0 - .with_frame(BodyFixed(Thrymr)) - .try_to_frame(frame, provider), - PyFrame::Narvi => self - .0 - .with_frame(BodyFixed(Narvi)) - .try_to_frame(frame, provider), - PyFrame::Methone => self - .0 - .with_frame(BodyFixed(Methone)) - .try_to_frame(frame, provider), - PyFrame::Pallene => self - .0 - .with_frame(BodyFixed(Pallene)) - .try_to_frame(frame, provider), - PyFrame::Polydeuces => self - .0 - .with_frame(BodyFixed(Polydeuces)) - .try_to_frame(frame, provider), - PyFrame::Daphnis => self - .0 - .with_frame(BodyFixed(Daphnis)) - .try_to_frame(frame, provider), - PyFrame::Aegir => self - .0 - .with_frame(BodyFixed(Aegir)) - .try_to_frame(frame, provider), - PyFrame::Bebhionn => self - .0 - .with_frame(BodyFixed(Bebhionn)) - .try_to_frame(frame, provider), - PyFrame::Bergelmir => self - .0 - .with_frame(BodyFixed(Bergelmir)) - .try_to_frame(frame, provider), - PyFrame::Bestla => self - .0 - .with_frame(BodyFixed(Bestla)) - .try_to_frame(frame, provider), - PyFrame::Farbauti => self - .0 - .with_frame(BodyFixed(Farbauti)) - .try_to_frame(frame, provider), - PyFrame::Fenrir => self - .0 - .with_frame(BodyFixed(Fenrir)) - .try_to_frame(frame, provider), - PyFrame::Fornjot => self - .0 - .with_frame(BodyFixed(Fornjot)) - .try_to_frame(frame, provider), - PyFrame::Hati => self - .0 - .with_frame(BodyFixed(Hati)) - .try_to_frame(frame, provider), - PyFrame::Hyrrokkin => self - .0 - .with_frame(BodyFixed(Hyrrokkin)) - .try_to_frame(frame, provider), - PyFrame::Kari => self - .0 - .with_frame(BodyFixed(Kari)) - .try_to_frame(frame, provider), - PyFrame::Loge => self - .0 - .with_frame(BodyFixed(Loge)) - .try_to_frame(frame, provider), - PyFrame::Skoll => self - .0 - .with_frame(BodyFixed(Skoll)) - .try_to_frame(frame, provider), - PyFrame::Surtur => self - .0 - .with_frame(BodyFixed(Surtur)) - .try_to_frame(frame, provider), - PyFrame::Anthe => self - .0 - .with_frame(BodyFixed(Anthe)) - .try_to_frame(frame, provider), - PyFrame::Jarnsaxa => self - .0 - .with_frame(BodyFixed(Jarnsaxa)) - .try_to_frame(frame, provider), - PyFrame::Greip => self - .0 - .with_frame(BodyFixed(Greip)) - .try_to_frame(frame, provider), - PyFrame::Tarqeq => self - .0 - .with_frame(BodyFixed(Tarqeq)) - .try_to_frame(frame, provider), - PyFrame::Aegaeon => self - .0 - .with_frame(BodyFixed(Aegaeon)) - .try_to_frame(frame, provider), - PyFrame::Ariel => self - .0 - .with_frame(BodyFixed(Ariel)) - .try_to_frame(frame, provider), - PyFrame::Umbriel => self - .0 - .with_frame(BodyFixed(Umbriel)) - .try_to_frame(frame, provider), - PyFrame::Titania => self - .0 - .with_frame(BodyFixed(Titania)) - .try_to_frame(frame, provider), - PyFrame::Oberon => self - .0 - .with_frame(BodyFixed(Oberon)) - .try_to_frame(frame, provider), - PyFrame::Miranda => self - .0 - .with_frame(BodyFixed(Miranda)) - .try_to_frame(frame, provider), - PyFrame::Cordelia => self - .0 - .with_frame(BodyFixed(Cordelia)) - .try_to_frame(frame, provider), - PyFrame::Ophelia => self - .0 - .with_frame(BodyFixed(Ophelia)) - .try_to_frame(frame, provider), - PyFrame::Bianca => self - .0 - .with_frame(BodyFixed(Bianca)) - .try_to_frame(frame, provider), - PyFrame::Cressida => self - .0 - .with_frame(BodyFixed(Cressida)) - .try_to_frame(frame, provider), - PyFrame::Desdemona => self - .0 - .with_frame(BodyFixed(Desdemona)) - .try_to_frame(frame, provider), - PyFrame::Juliet => self - .0 - .with_frame(BodyFixed(Juliet)) - .try_to_frame(frame, provider), - PyFrame::Portia => self - .0 - .with_frame(BodyFixed(Portia)) - .try_to_frame(frame, provider), - PyFrame::Rosalind => self - .0 - .with_frame(BodyFixed(Rosalind)) - .try_to_frame(frame, provider), - PyFrame::Belinda => self - .0 - .with_frame(BodyFixed(Belinda)) - .try_to_frame(frame, provider), - PyFrame::Puck => self - .0 - .with_frame(BodyFixed(Puck)) - .try_to_frame(frame, provider), - PyFrame::Caliban => self - .0 - .with_frame(BodyFixed(Caliban)) - .try_to_frame(frame, provider), - PyFrame::Sycorax => self - .0 - .with_frame(BodyFixed(Sycorax)) - .try_to_frame(frame, provider), - PyFrame::Prospero => self - .0 - .with_frame(BodyFixed(Prospero)) - .try_to_frame(frame, provider), - PyFrame::Setebos => self - .0 - .with_frame(BodyFixed(Setebos)) - .try_to_frame(frame, provider), - PyFrame::Stephano => self - .0 - .with_frame(BodyFixed(Stephano)) - .try_to_frame(frame, provider), - PyFrame::Trinculo => self - .0 - .with_frame(BodyFixed(Trinculo)) - .try_to_frame(frame, provider), - PyFrame::Francisco => self - .0 - .with_frame(BodyFixed(Francisco)) - .try_to_frame(frame, provider), - PyFrame::Margaret => self - .0 - .with_frame(BodyFixed(Margaret)) - .try_to_frame(frame, provider), - PyFrame::Ferdinand => self - .0 - .with_frame(BodyFixed(Ferdinand)) - .try_to_frame(frame, provider), - PyFrame::Perdita => self - .0 - .with_frame(BodyFixed(Perdita)) - .try_to_frame(frame, provider), - PyFrame::Mab => self - .0 - .with_frame(BodyFixed(Mab)) - .try_to_frame(frame, provider), - PyFrame::Cupid => self - .0 - .with_frame(BodyFixed(Cupid)) - .try_to_frame(frame, provider), - PyFrame::Triton => self - .0 - .with_frame(BodyFixed(Triton)) - .try_to_frame(frame, provider), - PyFrame::Nereid => self - .0 - .with_frame(BodyFixed(Nereid)) - .try_to_frame(frame, provider), - PyFrame::Naiad => self - .0 - .with_frame(BodyFixed(Naiad)) - .try_to_frame(frame, provider), - PyFrame::Thalassa => self - .0 - .with_frame(BodyFixed(Thalassa)) - .try_to_frame(frame, provider), - PyFrame::Despina => self - .0 - .with_frame(BodyFixed(Despina)) - .try_to_frame(frame, provider), - PyFrame::Galatea => self - .0 - .with_frame(BodyFixed(Galatea)) - .try_to_frame(frame, provider), - PyFrame::Larissa => self - .0 - .with_frame(BodyFixed(Larissa)) - .try_to_frame(frame, provider), - PyFrame::Proteus => self - .0 - .with_frame(BodyFixed(Proteus)) - .try_to_frame(frame, provider), - PyFrame::Halimede => self - .0 - .with_frame(BodyFixed(Halimede)) - .try_to_frame(frame, provider), - PyFrame::Psamathe => self - .0 - .with_frame(BodyFixed(Psamathe)) - .try_to_frame(frame, provider), - PyFrame::Sao => self - .0 - .with_frame(BodyFixed(Sao)) - .try_to_frame(frame, provider), - PyFrame::Laomedeia => self - .0 - .with_frame(BodyFixed(Laomedeia)) - .try_to_frame(frame, provider), - PyFrame::Neso => self - .0 - .with_frame(BodyFixed(Neso)) - .try_to_frame(frame, provider), - PyFrame::Charon => self - .0 - .with_frame(BodyFixed(Charon)) - .try_to_frame(frame, provider), - PyFrame::Nix => self - .0 - .with_frame(BodyFixed(Nix)) - .try_to_frame(frame, provider), - PyFrame::Hydra => self - .0 - .with_frame(BodyFixed(Hydra)) - .try_to_frame(frame, provider), - PyFrame::Kerberos => self - .0 - .with_frame(BodyFixed(Kerberos)) - .try_to_frame(frame, provider), - PyFrame::Styx => self - .0 - .with_frame(BodyFixed(Styx)) - .try_to_frame(frame, provider), - PyFrame::Gaspra => self - .0 - .with_frame(BodyFixed(Gaspra)) - .try_to_frame(frame, provider), - PyFrame::Ida => self - .0 - .with_frame(BodyFixed(Ida)) - .try_to_frame(frame, provider), - PyFrame::Dactyl => self - .0 - .with_frame(BodyFixed(Dactyl)) - .try_to_frame(frame, provider), - PyFrame::Ceres => self - .0 - .with_frame(BodyFixed(Ceres)) - .try_to_frame(frame, provider), - PyFrame::Pallas => self - .0 - .with_frame(BodyFixed(Pallas)) - .try_to_frame(frame, provider), - PyFrame::Vesta => self - .0 - .with_frame(BodyFixed(Vesta)) - .try_to_frame(frame, provider), - PyFrame::Psyche => self - .0 - .with_frame(BodyFixed(Psyche)) - .try_to_frame(frame, provider), - PyFrame::Lutetia => self - .0 - .with_frame(BodyFixed(Lutetia)) - .try_to_frame(frame, provider), - PyFrame::Kleopatra => self - .0 - .with_frame(BodyFixed(Kleopatra)) - .try_to_frame(frame, provider), - PyFrame::Eros => self - .0 - .with_frame(BodyFixed(Eros)) - .try_to_frame(frame, provider), - PyFrame::Davida => self - .0 - .with_frame(BodyFixed(Davida)) - .try_to_frame(frame, provider), - PyFrame::Mathilde => self - .0 - .with_frame(BodyFixed(Mathilde)) - .try_to_frame(frame, provider), - PyFrame::Steins => self - .0 - .with_frame(BodyFixed(Steins)) - .try_to_frame(frame, provider), - PyFrame::Braille => self - .0 - .with_frame(BodyFixed(Braille)) - .try_to_frame(frame, provider), - PyFrame::WilsonHarrington => self - .0 - .with_frame(BodyFixed(WilsonHarrington)) - .try_to_frame(frame, provider), - PyFrame::Toutatis => self - .0 - .with_frame(BodyFixed(Toutatis)) - .try_to_frame(frame, provider), - PyFrame::Itokawa => self - .0 - .with_frame(BodyFixed(Itokawa)) - .try_to_frame(frame, provider), - PyFrame::Bennu => self - .0 - .with_frame(BodyFixed(Bennu)) - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Sun => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Mercury => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Venus => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Earth => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Mars => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Jupiter => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Saturn => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Uranus => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Neptune => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Pluto => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Moon => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Phobos => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Deimos => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Io => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Europa => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Ganymede => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Callisto => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Amalthea => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Himalia => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Elara => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Pasiphae => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Sinope => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Lysithea => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Carme => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Ananke => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Leda => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Thebe => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Adrastea => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Metis => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Callirrhoe => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Themisto => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Magaclite => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Taygete => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Chaldene => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Harpalyke => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Kalyke => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Iocaste => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Erinome => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Isonoe => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Praxidike => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Autonoe => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Thyone => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Hermippe => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Aitne => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Eurydome => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Euanthe => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Euporie => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Orthosie => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Sponde => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Kale => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Pasithee => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Hegemone => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Mneme => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Aoede => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Thelxinoe => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Arche => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Kallichore => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Helike => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Carpo => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Eukelade => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Cyllene => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Kore => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Herse => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Dia => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Mimas => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Enceladus => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Tethys => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Dione => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Rhea => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Titan => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Hyperion => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Iapetus => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Phoebe => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Janus => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Epimetheus => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Helene => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Telesto => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Calypso => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Atlas => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Prometheus => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Pandora => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Pan => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Ymir => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Paaliaq => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Tarvos => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Ijiraq => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Suttungr => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Kiviuq => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Mundilfari => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Albiorix => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Skathi => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Erriapus => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Siarnaq => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Thrymr => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Narvi => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Methone => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Pallene => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Polydeuces => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Daphnis => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Aegir => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Bebhionn => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Bergelmir => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Bestla => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Farbauti => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Fenrir => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Fornjot => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Hati => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Hyrrokkin => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Kari => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Loge => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Skoll => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Surtur => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Anthe => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Jarnsaxa => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Greip => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Tarqeq => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Aegaeon => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Ariel => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Umbriel => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Titania => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Oberon => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Miranda => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Cordelia => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Ophelia => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Bianca => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Cressida => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Desdemona => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Juliet => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Portia => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Rosalind => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Belinda => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Puck => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Caliban => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Sycorax => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Prospero => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Setebos => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Stephano => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Trinculo => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Francisco => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Margaret => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Ferdinand => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Perdita => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Mab => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Cupid => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Triton => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Nereid => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Naiad => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Thalassa => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Despina => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Galatea => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Larissa => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Proteus => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Halimede => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Psamathe => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Sao => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Laomedeia => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Neso => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Charon => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Nix => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Hydra => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Kerberos => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Styx => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Gaspra => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Ida => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Dactyl => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Ceres => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Pallas => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Vesta => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Psyche => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Lutetia => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Kleopatra => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Eros => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Davida => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Mathilde => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Steins => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Braille => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::WilsonHarrington => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Toutatis => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Itokawa => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl TryToFrame, T> for PyState -where - T: FrameTransformationProvider + PyDeltaUt1Provider, -{ - type Output = State>; - type Error = T::Error; - fn try_to_frame( - &self, - frame: BodyFixed, - provider: &T, - ) -> Result>, T::Error> { - match self.0.reference_frame() { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::Bennu => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - } - } -} -impl PyState { - pub fn to_frame_generated( - &self, - frame: PyFrame, - provider: Option<&Bound<'_, PyUt1Provider>>, - ) -> PyResult { - match frame { - PyFrame::Icrf => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(Icrf, provider.get())? - .with_frame(PyFrame::Icrf), - )), - None => Ok(PyState( - self.try_to_frame(Icrf, &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Icrf), - )), - }, - PyFrame::Sun => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Sun), provider.get())? - .with_frame(PyFrame::Sun), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Sun), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Sun), - )), - }, - PyFrame::Mercury => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Mercury), provider.get())? - .with_frame(PyFrame::Mercury), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Mercury), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Mercury), - )), - }, - PyFrame::Venus => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Venus), provider.get())? - .with_frame(PyFrame::Venus), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Venus), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Venus), - )), - }, - PyFrame::Earth => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Earth), provider.get())? - .with_frame(PyFrame::Earth), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Earth), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Earth), - )), - }, - PyFrame::Mars => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Mars), provider.get())? - .with_frame(PyFrame::Mars), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Mars), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Mars), - )), - }, - PyFrame::Jupiter => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Jupiter), provider.get())? - .with_frame(PyFrame::Jupiter), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Jupiter), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Jupiter), - )), - }, - PyFrame::Saturn => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Saturn), provider.get())? - .with_frame(PyFrame::Saturn), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Saturn), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Saturn), - )), - }, - PyFrame::Uranus => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Uranus), provider.get())? - .with_frame(PyFrame::Uranus), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Uranus), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Uranus), - )), - }, - PyFrame::Neptune => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Neptune), provider.get())? - .with_frame(PyFrame::Neptune), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Neptune), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Neptune), - )), - }, - PyFrame::Pluto => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Pluto), provider.get())? - .with_frame(PyFrame::Pluto), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Pluto), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Pluto), - )), - }, - PyFrame::Moon => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Moon), provider.get())? - .with_frame(PyFrame::Moon), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Moon), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Moon), - )), - }, - PyFrame::Phobos => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Phobos), provider.get())? - .with_frame(PyFrame::Phobos), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Phobos), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Phobos), - )), - }, - PyFrame::Deimos => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Deimos), provider.get())? - .with_frame(PyFrame::Deimos), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Deimos), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Deimos), - )), - }, - PyFrame::Io => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Io), provider.get())? - .with_frame(PyFrame::Io), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Io), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Io), - )), - }, - PyFrame::Europa => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Europa), provider.get())? - .with_frame(PyFrame::Europa), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Europa), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Europa), - )), - }, - PyFrame::Ganymede => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Ganymede), provider.get())? - .with_frame(PyFrame::Ganymede), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Ganymede), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Ganymede), - )), - }, - PyFrame::Callisto => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Callisto), provider.get())? - .with_frame(PyFrame::Callisto), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Callisto), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Callisto), - )), - }, - PyFrame::Amalthea => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Amalthea), provider.get())? - .with_frame(PyFrame::Amalthea), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Amalthea), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Amalthea), - )), - }, - PyFrame::Himalia => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Himalia), provider.get())? - .with_frame(PyFrame::Himalia), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Himalia), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Himalia), - )), - }, - PyFrame::Elara => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Elara), provider.get())? - .with_frame(PyFrame::Elara), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Elara), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Elara), - )), - }, - PyFrame::Pasiphae => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Pasiphae), provider.get())? - .with_frame(PyFrame::Pasiphae), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Pasiphae), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Pasiphae), - )), - }, - PyFrame::Sinope => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Sinope), provider.get())? - .with_frame(PyFrame::Sinope), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Sinope), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Sinope), - )), - }, - PyFrame::Lysithea => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Lysithea), provider.get())? - .with_frame(PyFrame::Lysithea), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Lysithea), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Lysithea), - )), - }, - PyFrame::Carme => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Carme), provider.get())? - .with_frame(PyFrame::Carme), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Carme), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Carme), - )), - }, - PyFrame::Ananke => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Ananke), provider.get())? - .with_frame(PyFrame::Ananke), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Ananke), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Ananke), - )), - }, - PyFrame::Leda => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Leda), provider.get())? - .with_frame(PyFrame::Leda), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Leda), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Leda), - )), - }, - PyFrame::Thebe => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Thebe), provider.get())? - .with_frame(PyFrame::Thebe), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Thebe), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Thebe), - )), - }, - PyFrame::Adrastea => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Adrastea), provider.get())? - .with_frame(PyFrame::Adrastea), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Adrastea), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Adrastea), - )), - }, - PyFrame::Metis => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Metis), provider.get())? - .with_frame(PyFrame::Metis), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Metis), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Metis), - )), - }, - PyFrame::Callirrhoe => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Callirrhoe), provider.get())? - .with_frame(PyFrame::Callirrhoe), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Callirrhoe), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Callirrhoe), - )), - }, - PyFrame::Themisto => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Themisto), provider.get())? - .with_frame(PyFrame::Themisto), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Themisto), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Themisto), - )), - }, - PyFrame::Magaclite => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Magaclite), provider.get())? - .with_frame(PyFrame::Magaclite), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Magaclite), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Magaclite), - )), - }, - PyFrame::Taygete => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Taygete), provider.get())? - .with_frame(PyFrame::Taygete), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Taygete), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Taygete), - )), - }, - PyFrame::Chaldene => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Chaldene), provider.get())? - .with_frame(PyFrame::Chaldene), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Chaldene), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Chaldene), - )), - }, - PyFrame::Harpalyke => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Harpalyke), provider.get())? - .with_frame(PyFrame::Harpalyke), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Harpalyke), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Harpalyke), - )), - }, - PyFrame::Kalyke => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Kalyke), provider.get())? - .with_frame(PyFrame::Kalyke), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Kalyke), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Kalyke), - )), - }, - PyFrame::Iocaste => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Iocaste), provider.get())? - .with_frame(PyFrame::Iocaste), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Iocaste), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Iocaste), - )), - }, - PyFrame::Erinome => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Erinome), provider.get())? - .with_frame(PyFrame::Erinome), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Erinome), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Erinome), - )), - }, - PyFrame::Isonoe => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Isonoe), provider.get())? - .with_frame(PyFrame::Isonoe), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Isonoe), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Isonoe), - )), - }, - PyFrame::Praxidike => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Praxidike), provider.get())? - .with_frame(PyFrame::Praxidike), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Praxidike), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Praxidike), - )), - }, - PyFrame::Autonoe => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Autonoe), provider.get())? - .with_frame(PyFrame::Autonoe), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Autonoe), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Autonoe), - )), - }, - PyFrame::Thyone => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Thyone), provider.get())? - .with_frame(PyFrame::Thyone), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Thyone), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Thyone), - )), - }, - PyFrame::Hermippe => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Hermippe), provider.get())? - .with_frame(PyFrame::Hermippe), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Hermippe), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Hermippe), - )), - }, - PyFrame::Aitne => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Aitne), provider.get())? - .with_frame(PyFrame::Aitne), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Aitne), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Aitne), - )), - }, - PyFrame::Eurydome => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Eurydome), provider.get())? - .with_frame(PyFrame::Eurydome), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Eurydome), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Eurydome), - )), - }, - PyFrame::Euanthe => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Euanthe), provider.get())? - .with_frame(PyFrame::Euanthe), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Euanthe), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Euanthe), - )), - }, - PyFrame::Euporie => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Euporie), provider.get())? - .with_frame(PyFrame::Euporie), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Euporie), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Euporie), - )), - }, - PyFrame::Orthosie => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Orthosie), provider.get())? - .with_frame(PyFrame::Orthosie), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Orthosie), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Orthosie), - )), - }, - PyFrame::Sponde => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Sponde), provider.get())? - .with_frame(PyFrame::Sponde), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Sponde), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Sponde), - )), - }, - PyFrame::Kale => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Kale), provider.get())? - .with_frame(PyFrame::Kale), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Kale), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Kale), - )), - }, - PyFrame::Pasithee => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Pasithee), provider.get())? - .with_frame(PyFrame::Pasithee), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Pasithee), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Pasithee), - )), - }, - PyFrame::Hegemone => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Hegemone), provider.get())? - .with_frame(PyFrame::Hegemone), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Hegemone), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Hegemone), - )), - }, - PyFrame::Mneme => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Mneme), provider.get())? - .with_frame(PyFrame::Mneme), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Mneme), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Mneme), - )), - }, - PyFrame::Aoede => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Aoede), provider.get())? - .with_frame(PyFrame::Aoede), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Aoede), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Aoede), - )), - }, - PyFrame::Thelxinoe => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Thelxinoe), provider.get())? - .with_frame(PyFrame::Thelxinoe), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Thelxinoe), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Thelxinoe), - )), - }, - PyFrame::Arche => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Arche), provider.get())? - .with_frame(PyFrame::Arche), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Arche), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Arche), - )), - }, - PyFrame::Kallichore => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Kallichore), provider.get())? - .with_frame(PyFrame::Kallichore), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Kallichore), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Kallichore), - )), - }, - PyFrame::Helike => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Helike), provider.get())? - .with_frame(PyFrame::Helike), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Helike), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Helike), - )), - }, - PyFrame::Carpo => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Carpo), provider.get())? - .with_frame(PyFrame::Carpo), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Carpo), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Carpo), - )), - }, - PyFrame::Eukelade => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Eukelade), provider.get())? - .with_frame(PyFrame::Eukelade), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Eukelade), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Eukelade), - )), - }, - PyFrame::Cyllene => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Cyllene), provider.get())? - .with_frame(PyFrame::Cyllene), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Cyllene), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Cyllene), - )), - }, - PyFrame::Kore => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Kore), provider.get())? - .with_frame(PyFrame::Kore), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Kore), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Kore), - )), - }, - PyFrame::Herse => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Herse), provider.get())? - .with_frame(PyFrame::Herse), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Herse), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Herse), - )), - }, - PyFrame::Dia => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Dia), provider.get())? - .with_frame(PyFrame::Dia), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Dia), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Dia), - )), - }, - PyFrame::Mimas => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Mimas), provider.get())? - .with_frame(PyFrame::Mimas), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Mimas), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Mimas), - )), - }, - PyFrame::Enceladus => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Enceladus), provider.get())? - .with_frame(PyFrame::Enceladus), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Enceladus), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Enceladus), - )), - }, - PyFrame::Tethys => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Tethys), provider.get())? - .with_frame(PyFrame::Tethys), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Tethys), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Tethys), - )), - }, - PyFrame::Dione => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Dione), provider.get())? - .with_frame(PyFrame::Dione), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Dione), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Dione), - )), - }, - PyFrame::Rhea => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Rhea), provider.get())? - .with_frame(PyFrame::Rhea), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Rhea), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Rhea), - )), - }, - PyFrame::Titan => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Titan), provider.get())? - .with_frame(PyFrame::Titan), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Titan), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Titan), - )), - }, - PyFrame::Hyperion => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Hyperion), provider.get())? - .with_frame(PyFrame::Hyperion), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Hyperion), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Hyperion), - )), - }, - PyFrame::Iapetus => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Iapetus), provider.get())? - .with_frame(PyFrame::Iapetus), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Iapetus), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Iapetus), - )), - }, - PyFrame::Phoebe => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Phoebe), provider.get())? - .with_frame(PyFrame::Phoebe), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Phoebe), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Phoebe), - )), - }, - PyFrame::Janus => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Janus), provider.get())? - .with_frame(PyFrame::Janus), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Janus), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Janus), - )), - }, - PyFrame::Epimetheus => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Epimetheus), provider.get())? - .with_frame(PyFrame::Epimetheus), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Epimetheus), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Epimetheus), - )), - }, - PyFrame::Helene => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Helene), provider.get())? - .with_frame(PyFrame::Helene), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Helene), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Helene), - )), - }, - PyFrame::Telesto => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Telesto), provider.get())? - .with_frame(PyFrame::Telesto), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Telesto), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Telesto), - )), - }, - PyFrame::Calypso => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Calypso), provider.get())? - .with_frame(PyFrame::Calypso), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Calypso), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Calypso), - )), - }, - PyFrame::Atlas => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Atlas), provider.get())? - .with_frame(PyFrame::Atlas), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Atlas), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Atlas), - )), - }, - PyFrame::Prometheus => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Prometheus), provider.get())? - .with_frame(PyFrame::Prometheus), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Prometheus), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Prometheus), - )), - }, - PyFrame::Pandora => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Pandora), provider.get())? - .with_frame(PyFrame::Pandora), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Pandora), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Pandora), - )), - }, - PyFrame::Pan => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Pan), provider.get())? - .with_frame(PyFrame::Pan), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Pan), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Pan), - )), - }, - PyFrame::Ymir => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Ymir), provider.get())? - .with_frame(PyFrame::Ymir), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Ymir), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Ymir), - )), - }, - PyFrame::Paaliaq => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Paaliaq), provider.get())? - .with_frame(PyFrame::Paaliaq), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Paaliaq), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Paaliaq), - )), - }, - PyFrame::Tarvos => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Tarvos), provider.get())? - .with_frame(PyFrame::Tarvos), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Tarvos), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Tarvos), - )), - }, - PyFrame::Ijiraq => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Ijiraq), provider.get())? - .with_frame(PyFrame::Ijiraq), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Ijiraq), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Ijiraq), - )), - }, - PyFrame::Suttungr => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Suttungr), provider.get())? - .with_frame(PyFrame::Suttungr), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Suttungr), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Suttungr), - )), - }, - PyFrame::Kiviuq => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Kiviuq), provider.get())? - .with_frame(PyFrame::Kiviuq), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Kiviuq), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Kiviuq), - )), - }, - PyFrame::Mundilfari => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Mundilfari), provider.get())? - .with_frame(PyFrame::Mundilfari), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Mundilfari), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Mundilfari), - )), - }, - PyFrame::Albiorix => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Albiorix), provider.get())? - .with_frame(PyFrame::Albiorix), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Albiorix), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Albiorix), - )), - }, - PyFrame::Skathi => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Skathi), provider.get())? - .with_frame(PyFrame::Skathi), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Skathi), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Skathi), - )), - }, - PyFrame::Erriapus => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Erriapus), provider.get())? - .with_frame(PyFrame::Erriapus), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Erriapus), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Erriapus), - )), - }, - PyFrame::Siarnaq => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Siarnaq), provider.get())? - .with_frame(PyFrame::Siarnaq), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Siarnaq), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Siarnaq), - )), - }, - PyFrame::Thrymr => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Thrymr), provider.get())? - .with_frame(PyFrame::Thrymr), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Thrymr), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Thrymr), - )), - }, - PyFrame::Narvi => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Narvi), provider.get())? - .with_frame(PyFrame::Narvi), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Narvi), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Narvi), - )), - }, - PyFrame::Methone => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Methone), provider.get())? - .with_frame(PyFrame::Methone), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Methone), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Methone), - )), - }, - PyFrame::Pallene => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Pallene), provider.get())? - .with_frame(PyFrame::Pallene), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Pallene), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Pallene), - )), - }, - PyFrame::Polydeuces => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Polydeuces), provider.get())? - .with_frame(PyFrame::Polydeuces), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Polydeuces), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Polydeuces), - )), - }, - PyFrame::Daphnis => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Daphnis), provider.get())? - .with_frame(PyFrame::Daphnis), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Daphnis), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Daphnis), - )), - }, - PyFrame::Aegir => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Aegir), provider.get())? - .with_frame(PyFrame::Aegir), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Aegir), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Aegir), - )), - }, - PyFrame::Bebhionn => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Bebhionn), provider.get())? - .with_frame(PyFrame::Bebhionn), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Bebhionn), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Bebhionn), - )), - }, - PyFrame::Bergelmir => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Bergelmir), provider.get())? - .with_frame(PyFrame::Bergelmir), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Bergelmir), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Bergelmir), - )), - }, - PyFrame::Bestla => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Bestla), provider.get())? - .with_frame(PyFrame::Bestla), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Bestla), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Bestla), - )), - }, - PyFrame::Farbauti => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Farbauti), provider.get())? - .with_frame(PyFrame::Farbauti), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Farbauti), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Farbauti), - )), - }, - PyFrame::Fenrir => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Fenrir), provider.get())? - .with_frame(PyFrame::Fenrir), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Fenrir), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Fenrir), - )), - }, - PyFrame::Fornjot => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Fornjot), provider.get())? - .with_frame(PyFrame::Fornjot), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Fornjot), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Fornjot), - )), - }, - PyFrame::Hati => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Hati), provider.get())? - .with_frame(PyFrame::Hati), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Hati), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Hati), - )), - }, - PyFrame::Hyrrokkin => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Hyrrokkin), provider.get())? - .with_frame(PyFrame::Hyrrokkin), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Hyrrokkin), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Hyrrokkin), - )), - }, - PyFrame::Kari => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Kari), provider.get())? - .with_frame(PyFrame::Kari), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Kari), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Kari), - )), - }, - PyFrame::Loge => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Loge), provider.get())? - .with_frame(PyFrame::Loge), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Loge), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Loge), - )), - }, - PyFrame::Skoll => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Skoll), provider.get())? - .with_frame(PyFrame::Skoll), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Skoll), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Skoll), - )), - }, - PyFrame::Surtur => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Surtur), provider.get())? - .with_frame(PyFrame::Surtur), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Surtur), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Surtur), - )), - }, - PyFrame::Anthe => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Anthe), provider.get())? - .with_frame(PyFrame::Anthe), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Anthe), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Anthe), - )), - }, - PyFrame::Jarnsaxa => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Jarnsaxa), provider.get())? - .with_frame(PyFrame::Jarnsaxa), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Jarnsaxa), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Jarnsaxa), - )), - }, - PyFrame::Greip => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Greip), provider.get())? - .with_frame(PyFrame::Greip), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Greip), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Greip), - )), - }, - PyFrame::Tarqeq => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Tarqeq), provider.get())? - .with_frame(PyFrame::Tarqeq), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Tarqeq), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Tarqeq), - )), - }, - PyFrame::Aegaeon => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Aegaeon), provider.get())? - .with_frame(PyFrame::Aegaeon), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Aegaeon), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Aegaeon), - )), - }, - PyFrame::Ariel => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Ariel), provider.get())? - .with_frame(PyFrame::Ariel), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Ariel), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Ariel), - )), - }, - PyFrame::Umbriel => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Umbriel), provider.get())? - .with_frame(PyFrame::Umbriel), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Umbriel), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Umbriel), - )), - }, - PyFrame::Titania => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Titania), provider.get())? - .with_frame(PyFrame::Titania), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Titania), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Titania), - )), - }, - PyFrame::Oberon => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Oberon), provider.get())? - .with_frame(PyFrame::Oberon), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Oberon), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Oberon), - )), - }, - PyFrame::Miranda => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Miranda), provider.get())? - .with_frame(PyFrame::Miranda), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Miranda), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Miranda), - )), - }, - PyFrame::Cordelia => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Cordelia), provider.get())? - .with_frame(PyFrame::Cordelia), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Cordelia), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Cordelia), - )), - }, - PyFrame::Ophelia => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Ophelia), provider.get())? - .with_frame(PyFrame::Ophelia), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Ophelia), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Ophelia), - )), - }, - PyFrame::Bianca => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Bianca), provider.get())? - .with_frame(PyFrame::Bianca), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Bianca), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Bianca), - )), - }, - PyFrame::Cressida => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Cressida), provider.get())? - .with_frame(PyFrame::Cressida), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Cressida), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Cressida), - )), - }, - PyFrame::Desdemona => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Desdemona), provider.get())? - .with_frame(PyFrame::Desdemona), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Desdemona), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Desdemona), - )), - }, - PyFrame::Juliet => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Juliet), provider.get())? - .with_frame(PyFrame::Juliet), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Juliet), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Juliet), - )), - }, - PyFrame::Portia => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Portia), provider.get())? - .with_frame(PyFrame::Portia), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Portia), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Portia), - )), - }, - PyFrame::Rosalind => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Rosalind), provider.get())? - .with_frame(PyFrame::Rosalind), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Rosalind), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Rosalind), - )), - }, - PyFrame::Belinda => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Belinda), provider.get())? - .with_frame(PyFrame::Belinda), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Belinda), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Belinda), - )), - }, - PyFrame::Puck => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Puck), provider.get())? - .with_frame(PyFrame::Puck), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Puck), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Puck), - )), - }, - PyFrame::Caliban => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Caliban), provider.get())? - .with_frame(PyFrame::Caliban), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Caliban), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Caliban), - )), - }, - PyFrame::Sycorax => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Sycorax), provider.get())? - .with_frame(PyFrame::Sycorax), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Sycorax), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Sycorax), - )), - }, - PyFrame::Prospero => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Prospero), provider.get())? - .with_frame(PyFrame::Prospero), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Prospero), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Prospero), - )), - }, - PyFrame::Setebos => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Setebos), provider.get())? - .with_frame(PyFrame::Setebos), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Setebos), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Setebos), - )), - }, - PyFrame::Stephano => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Stephano), provider.get())? - .with_frame(PyFrame::Stephano), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Stephano), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Stephano), - )), - }, - PyFrame::Trinculo => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Trinculo), provider.get())? - .with_frame(PyFrame::Trinculo), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Trinculo), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Trinculo), - )), - }, - PyFrame::Francisco => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Francisco), provider.get())? - .with_frame(PyFrame::Francisco), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Francisco), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Francisco), - )), - }, - PyFrame::Margaret => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Margaret), provider.get())? - .with_frame(PyFrame::Margaret), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Margaret), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Margaret), - )), - }, - PyFrame::Ferdinand => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Ferdinand), provider.get())? - .with_frame(PyFrame::Ferdinand), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Ferdinand), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Ferdinand), - )), - }, - PyFrame::Perdita => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Perdita), provider.get())? - .with_frame(PyFrame::Perdita), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Perdita), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Perdita), - )), - }, - PyFrame::Mab => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Mab), provider.get())? - .with_frame(PyFrame::Mab), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Mab), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Mab), - )), - }, - PyFrame::Cupid => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Cupid), provider.get())? - .with_frame(PyFrame::Cupid), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Cupid), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Cupid), - )), - }, - PyFrame::Triton => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Triton), provider.get())? - .with_frame(PyFrame::Triton), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Triton), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Triton), - )), - }, - PyFrame::Nereid => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Nereid), provider.get())? - .with_frame(PyFrame::Nereid), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Nereid), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Nereid), - )), - }, - PyFrame::Naiad => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Naiad), provider.get())? - .with_frame(PyFrame::Naiad), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Naiad), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Naiad), - )), - }, - PyFrame::Thalassa => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Thalassa), provider.get())? - .with_frame(PyFrame::Thalassa), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Thalassa), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Thalassa), - )), - }, - PyFrame::Despina => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Despina), provider.get())? - .with_frame(PyFrame::Despina), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Despina), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Despina), - )), - }, - PyFrame::Galatea => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Galatea), provider.get())? - .with_frame(PyFrame::Galatea), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Galatea), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Galatea), - )), - }, - PyFrame::Larissa => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Larissa), provider.get())? - .with_frame(PyFrame::Larissa), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Larissa), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Larissa), - )), - }, - PyFrame::Proteus => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Proteus), provider.get())? - .with_frame(PyFrame::Proteus), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Proteus), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Proteus), - )), - }, - PyFrame::Halimede => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Halimede), provider.get())? - .with_frame(PyFrame::Halimede), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Halimede), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Halimede), - )), - }, - PyFrame::Psamathe => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Psamathe), provider.get())? - .with_frame(PyFrame::Psamathe), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Psamathe), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Psamathe), - )), - }, - PyFrame::Sao => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Sao), provider.get())? - .with_frame(PyFrame::Sao), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Sao), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Sao), - )), - }, - PyFrame::Laomedeia => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Laomedeia), provider.get())? - .with_frame(PyFrame::Laomedeia), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Laomedeia), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Laomedeia), - )), - }, - PyFrame::Neso => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Neso), provider.get())? - .with_frame(PyFrame::Neso), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Neso), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Neso), - )), - }, - PyFrame::Charon => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Charon), provider.get())? - .with_frame(PyFrame::Charon), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Charon), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Charon), - )), - }, - PyFrame::Nix => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Nix), provider.get())? - .with_frame(PyFrame::Nix), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Nix), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Nix), - )), - }, - PyFrame::Hydra => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Hydra), provider.get())? - .with_frame(PyFrame::Hydra), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Hydra), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Hydra), - )), - }, - PyFrame::Kerberos => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Kerberos), provider.get())? - .with_frame(PyFrame::Kerberos), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Kerberos), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Kerberos), - )), - }, - PyFrame::Styx => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Styx), provider.get())? - .with_frame(PyFrame::Styx), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Styx), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Styx), - )), - }, - PyFrame::Gaspra => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Gaspra), provider.get())? - .with_frame(PyFrame::Gaspra), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Gaspra), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Gaspra), - )), - }, - PyFrame::Ida => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Ida), provider.get())? - .with_frame(PyFrame::Ida), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Ida), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Ida), - )), - }, - PyFrame::Dactyl => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Dactyl), provider.get())? - .with_frame(PyFrame::Dactyl), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Dactyl), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Dactyl), - )), - }, - PyFrame::Ceres => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Ceres), provider.get())? - .with_frame(PyFrame::Ceres), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Ceres), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Ceres), - )), - }, - PyFrame::Pallas => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Pallas), provider.get())? - .with_frame(PyFrame::Pallas), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Pallas), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Pallas), - )), - }, - PyFrame::Vesta => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Vesta), provider.get())? - .with_frame(PyFrame::Vesta), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Vesta), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Vesta), - )), - }, - PyFrame::Psyche => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Psyche), provider.get())? - .with_frame(PyFrame::Psyche), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Psyche), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Psyche), - )), - }, - PyFrame::Lutetia => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Lutetia), provider.get())? - .with_frame(PyFrame::Lutetia), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Lutetia), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Lutetia), - )), - }, - PyFrame::Kleopatra => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Kleopatra), provider.get())? - .with_frame(PyFrame::Kleopatra), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Kleopatra), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Kleopatra), - )), - }, - PyFrame::Eros => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Eros), provider.get())? - .with_frame(PyFrame::Eros), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Eros), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Eros), - )), - }, - PyFrame::Davida => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Davida), provider.get())? - .with_frame(PyFrame::Davida), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Davida), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Davida), - )), - }, - PyFrame::Mathilde => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Mathilde), provider.get())? - .with_frame(PyFrame::Mathilde), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Mathilde), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Mathilde), - )), - }, - PyFrame::Steins => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Steins), provider.get())? - .with_frame(PyFrame::Steins), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Steins), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Steins), - )), - }, - PyFrame::Braille => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Braille), provider.get())? - .with_frame(PyFrame::Braille), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Braille), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Braille), - )), - }, - PyFrame::WilsonHarrington => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(WilsonHarrington), provider.get())? - .with_frame(PyFrame::WilsonHarrington), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(WilsonHarrington), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::WilsonHarrington), - )), - }, - PyFrame::Toutatis => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Toutatis), provider.get())? - .with_frame(PyFrame::Toutatis), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Toutatis), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Toutatis), - )), - }, - PyFrame::Itokawa => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Itokawa), provider.get())? - .with_frame(PyFrame::Itokawa), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Itokawa), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Itokawa), - )), - }, - PyFrame::Bennu => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(Bennu), provider.get())? - .with_frame(PyFrame::Bennu), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(Bennu), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::Bennu), - )), - }, - } - } -} -impl ReferenceFrame for PyFrame { - fn name(&self) -> String { - match self { - PyFrame::Icrf => "International Celestial Reference Frame".to_string(), - PyFrame::Sun => "IAU Body-Fixed Frame for the Sun".to_string(), - PyFrame::Mercury => "IAU Body-Fixed Frame for Mercury".to_string(), - PyFrame::Venus => "IAU Body-Fixed Frame for Venus".to_string(), - PyFrame::Earth => "IAU Body-Fixed Frame for Earth".to_string(), - PyFrame::Mars => "IAU Body-Fixed Frame for Mars".to_string(), - PyFrame::Jupiter => "IAU Body-Fixed Frame for Jupiter".to_string(), - PyFrame::Saturn => "IAU Body-Fixed Frame for Saturn".to_string(), - PyFrame::Uranus => "IAU Body-Fixed Frame for Uranus".to_string(), - PyFrame::Neptune => "IAU Body-Fixed Frame for Neptune".to_string(), - PyFrame::Pluto => "IAU Body-Fixed Frame for Pluto".to_string(), - PyFrame::Moon => "IAU Body-Fixed Frame for the Moon".to_string(), - PyFrame::Phobos => "IAU Body-Fixed Frame for Phobos".to_string(), - PyFrame::Deimos => "IAU Body-Fixed Frame for Deimos".to_string(), - PyFrame::Io => "IAU Body-Fixed Frame for Io".to_string(), - PyFrame::Europa => "IAU Body-Fixed Frame for Europa".to_string(), - PyFrame::Ganymede => "IAU Body-Fixed Frame for Ganymede".to_string(), - PyFrame::Callisto => "IAU Body-Fixed Frame for Callisto".to_string(), - PyFrame::Amalthea => "IAU Body-Fixed Frame for Amalthea".to_string(), - PyFrame::Himalia => "IAU Body-Fixed Frame for Himalia".to_string(), - PyFrame::Elara => "IAU Body-Fixed Frame for Elara".to_string(), - PyFrame::Pasiphae => "IAU Body-Fixed Frame for Pasiphae".to_string(), - PyFrame::Sinope => "IAU Body-Fixed Frame for Sinope".to_string(), - PyFrame::Lysithea => "IAU Body-Fixed Frame for Lysithea".to_string(), - PyFrame::Carme => "IAU Body-Fixed Frame for Carme".to_string(), - PyFrame::Ananke => "IAU Body-Fixed Frame for Ananke".to_string(), - PyFrame::Leda => "IAU Body-Fixed Frame for Leda".to_string(), - PyFrame::Thebe => "IAU Body-Fixed Frame for Thebe".to_string(), - PyFrame::Adrastea => "IAU Body-Fixed Frame for Adrastea".to_string(), - PyFrame::Metis => "IAU Body-Fixed Frame for Metis".to_string(), - PyFrame::Callirrhoe => "IAU Body-Fixed Frame for Callirrhoe".to_string(), - PyFrame::Themisto => "IAU Body-Fixed Frame for Themisto".to_string(), - PyFrame::Magaclite => "IAU Body-Fixed Frame for Magaclite".to_string(), - PyFrame::Taygete => "IAU Body-Fixed Frame for Taygete".to_string(), - PyFrame::Chaldene => "IAU Body-Fixed Frame for Chaldene".to_string(), - PyFrame::Harpalyke => "IAU Body-Fixed Frame for Harpalyke".to_string(), - PyFrame::Kalyke => "IAU Body-Fixed Frame for Kalyke".to_string(), - PyFrame::Iocaste => "IAU Body-Fixed Frame for Iocaste".to_string(), - PyFrame::Erinome => "IAU Body-Fixed Frame for Erinome".to_string(), - PyFrame::Isonoe => "IAU Body-Fixed Frame for Isonoe".to_string(), - PyFrame::Praxidike => "IAU Body-Fixed Frame for Praxidike".to_string(), - PyFrame::Autonoe => "IAU Body-Fixed Frame for Autonoe".to_string(), - PyFrame::Thyone => "IAU Body-Fixed Frame for Thyone".to_string(), - PyFrame::Hermippe => "IAU Body-Fixed Frame for Hermippe".to_string(), - PyFrame::Aitne => "IAU Body-Fixed Frame for Aitne".to_string(), - PyFrame::Eurydome => "IAU Body-Fixed Frame for Eurydome".to_string(), - PyFrame::Euanthe => "IAU Body-Fixed Frame for Euanthe".to_string(), - PyFrame::Euporie => "IAU Body-Fixed Frame for Euporie".to_string(), - PyFrame::Orthosie => "IAU Body-Fixed Frame for Orthosie".to_string(), - PyFrame::Sponde => "IAU Body-Fixed Frame for Sponde".to_string(), - PyFrame::Kale => "IAU Body-Fixed Frame for Kale".to_string(), - PyFrame::Pasithee => "IAU Body-Fixed Frame for Pasithee".to_string(), - PyFrame::Hegemone => "IAU Body-Fixed Frame for Hegemone".to_string(), - PyFrame::Mneme => "IAU Body-Fixed Frame for Mneme".to_string(), - PyFrame::Aoede => "IAU Body-Fixed Frame for Aoede".to_string(), - PyFrame::Thelxinoe => "IAU Body-Fixed Frame for Thelxinoe".to_string(), - PyFrame::Arche => "IAU Body-Fixed Frame for Arche".to_string(), - PyFrame::Kallichore => "IAU Body-Fixed Frame for Kallichore".to_string(), - PyFrame::Helike => "IAU Body-Fixed Frame for Helike".to_string(), - PyFrame::Carpo => "IAU Body-Fixed Frame for Carpo".to_string(), - PyFrame::Eukelade => "IAU Body-Fixed Frame for Eukelade".to_string(), - PyFrame::Cyllene => "IAU Body-Fixed Frame for Cyllene".to_string(), - PyFrame::Kore => "IAU Body-Fixed Frame for Kore".to_string(), - PyFrame::Herse => "IAU Body-Fixed Frame for Herse".to_string(), - PyFrame::Dia => "IAU Body-Fixed Frame for Dia".to_string(), - PyFrame::Mimas => "IAU Body-Fixed Frame for Mimas".to_string(), - PyFrame::Enceladus => "IAU Body-Fixed Frame for Enceladus".to_string(), - PyFrame::Tethys => "IAU Body-Fixed Frame for Tethys".to_string(), - PyFrame::Dione => "IAU Body-Fixed Frame for Dione".to_string(), - PyFrame::Rhea => "IAU Body-Fixed Frame for Rhea".to_string(), - PyFrame::Titan => "IAU Body-Fixed Frame for Titan".to_string(), - PyFrame::Hyperion => "IAU Body-Fixed Frame for Hyperion".to_string(), - PyFrame::Iapetus => "IAU Body-Fixed Frame for Iapetus".to_string(), - PyFrame::Phoebe => "IAU Body-Fixed Frame for Phoebe".to_string(), - PyFrame::Janus => "IAU Body-Fixed Frame for Janus".to_string(), - PyFrame::Epimetheus => "IAU Body-Fixed Frame for Epimetheus".to_string(), - PyFrame::Helene => "IAU Body-Fixed Frame for Helene".to_string(), - PyFrame::Telesto => "IAU Body-Fixed Frame for Telesto".to_string(), - PyFrame::Calypso => "IAU Body-Fixed Frame for Calypso".to_string(), - PyFrame::Atlas => "IAU Body-Fixed Frame for Atlas".to_string(), - PyFrame::Prometheus => "IAU Body-Fixed Frame for Prometheus".to_string(), - PyFrame::Pandora => "IAU Body-Fixed Frame for Pandora".to_string(), - PyFrame::Pan => "IAU Body-Fixed Frame for Pan".to_string(), - PyFrame::Ymir => "IAU Body-Fixed Frame for Ymir".to_string(), - PyFrame::Paaliaq => "IAU Body-Fixed Frame for Paaliaq".to_string(), - PyFrame::Tarvos => "IAU Body-Fixed Frame for Tarvos".to_string(), - PyFrame::Ijiraq => "IAU Body-Fixed Frame for Ijiraq".to_string(), - PyFrame::Suttungr => "IAU Body-Fixed Frame for Suttungr".to_string(), - PyFrame::Kiviuq => "IAU Body-Fixed Frame for Kiviuq".to_string(), - PyFrame::Mundilfari => "IAU Body-Fixed Frame for Mundilfari".to_string(), - PyFrame::Albiorix => "IAU Body-Fixed Frame for Albiorix".to_string(), - PyFrame::Skathi => "IAU Body-Fixed Frame for Skathi".to_string(), - PyFrame::Erriapus => "IAU Body-Fixed Frame for Erriapus".to_string(), - PyFrame::Siarnaq => "IAU Body-Fixed Frame for Siarnaq".to_string(), - PyFrame::Thrymr => "IAU Body-Fixed Frame for Thrymr".to_string(), - PyFrame::Narvi => "IAU Body-Fixed Frame for Narvi".to_string(), - PyFrame::Methone => "IAU Body-Fixed Frame for Methone".to_string(), - PyFrame::Pallene => "IAU Body-Fixed Frame for Pallene".to_string(), - PyFrame::Polydeuces => "IAU Body-Fixed Frame for Polydeuces".to_string(), - PyFrame::Daphnis => "IAU Body-Fixed Frame for Daphnis".to_string(), - PyFrame::Aegir => "IAU Body-Fixed Frame for Aegir".to_string(), - PyFrame::Bebhionn => "IAU Body-Fixed Frame for Bebhionn".to_string(), - PyFrame::Bergelmir => "IAU Body-Fixed Frame for Bergelmir".to_string(), - PyFrame::Bestla => "IAU Body-Fixed Frame for Bestla".to_string(), - PyFrame::Farbauti => "IAU Body-Fixed Frame for Farbauti".to_string(), - PyFrame::Fenrir => "IAU Body-Fixed Frame for Fenrir".to_string(), - PyFrame::Fornjot => "IAU Body-Fixed Frame for Fornjot".to_string(), - PyFrame::Hati => "IAU Body-Fixed Frame for Hati".to_string(), - PyFrame::Hyrrokkin => "IAU Body-Fixed Frame for Hyrrokkin".to_string(), - PyFrame::Kari => "IAU Body-Fixed Frame for Kari".to_string(), - PyFrame::Loge => "IAU Body-Fixed Frame for Loge".to_string(), - PyFrame::Skoll => "IAU Body-Fixed Frame for Skoll".to_string(), - PyFrame::Surtur => "IAU Body-Fixed Frame for Surtur".to_string(), - PyFrame::Anthe => "IAU Body-Fixed Frame for Anthe".to_string(), - PyFrame::Jarnsaxa => "IAU Body-Fixed Frame for Jarnsaxa".to_string(), - PyFrame::Greip => "IAU Body-Fixed Frame for Greip".to_string(), - PyFrame::Tarqeq => "IAU Body-Fixed Frame for Tarqeq".to_string(), - PyFrame::Aegaeon => "IAU Body-Fixed Frame for Aegaeon".to_string(), - PyFrame::Ariel => "IAU Body-Fixed Frame for Ariel".to_string(), - PyFrame::Umbriel => "IAU Body-Fixed Frame for Umbriel".to_string(), - PyFrame::Titania => "IAU Body-Fixed Frame for Titania".to_string(), - PyFrame::Oberon => "IAU Body-Fixed Frame for Oberon".to_string(), - PyFrame::Miranda => "IAU Body-Fixed Frame for Miranda".to_string(), - PyFrame::Cordelia => "IAU Body-Fixed Frame for Cordelia".to_string(), - PyFrame::Ophelia => "IAU Body-Fixed Frame for Ophelia".to_string(), - PyFrame::Bianca => "IAU Body-Fixed Frame for Bianca".to_string(), - PyFrame::Cressida => "IAU Body-Fixed Frame for Cressida".to_string(), - PyFrame::Desdemona => "IAU Body-Fixed Frame for Desdemona".to_string(), - PyFrame::Juliet => "IAU Body-Fixed Frame for Juliet".to_string(), - PyFrame::Portia => "IAU Body-Fixed Frame for Portia".to_string(), - PyFrame::Rosalind => "IAU Body-Fixed Frame for Rosalind".to_string(), - PyFrame::Belinda => "IAU Body-Fixed Frame for Belinda".to_string(), - PyFrame::Puck => "IAU Body-Fixed Frame for Puck".to_string(), - PyFrame::Caliban => "IAU Body-Fixed Frame for Caliban".to_string(), - PyFrame::Sycorax => "IAU Body-Fixed Frame for Sycorax".to_string(), - PyFrame::Prospero => "IAU Body-Fixed Frame for Prospero".to_string(), - PyFrame::Setebos => "IAU Body-Fixed Frame for Setebos".to_string(), - PyFrame::Stephano => "IAU Body-Fixed Frame for Stephano".to_string(), - PyFrame::Trinculo => "IAU Body-Fixed Frame for Trinculo".to_string(), - PyFrame::Francisco => "IAU Body-Fixed Frame for Francisco".to_string(), - PyFrame::Margaret => "IAU Body-Fixed Frame for Margaret".to_string(), - PyFrame::Ferdinand => "IAU Body-Fixed Frame for Ferdinand".to_string(), - PyFrame::Perdita => "IAU Body-Fixed Frame for Perdita".to_string(), - PyFrame::Mab => "IAU Body-Fixed Frame for Mab".to_string(), - PyFrame::Cupid => "IAU Body-Fixed Frame for Cupid".to_string(), - PyFrame::Triton => "IAU Body-Fixed Frame for Triton".to_string(), - PyFrame::Nereid => "IAU Body-Fixed Frame for Nereid".to_string(), - PyFrame::Naiad => "IAU Body-Fixed Frame for Naiad".to_string(), - PyFrame::Thalassa => "IAU Body-Fixed Frame for Thalassa".to_string(), - PyFrame::Despina => "IAU Body-Fixed Frame for Despina".to_string(), - PyFrame::Galatea => "IAU Body-Fixed Frame for Galatea".to_string(), - PyFrame::Larissa => "IAU Body-Fixed Frame for Larissa".to_string(), - PyFrame::Proteus => "IAU Body-Fixed Frame for Proteus".to_string(), - PyFrame::Halimede => "IAU Body-Fixed Frame for Halimede".to_string(), - PyFrame::Psamathe => "IAU Body-Fixed Frame for Psamathe".to_string(), - PyFrame::Sao => "IAU Body-Fixed Frame for Sao".to_string(), - PyFrame::Laomedeia => "IAU Body-Fixed Frame for Laomedeia".to_string(), - PyFrame::Neso => "IAU Body-Fixed Frame for Neso".to_string(), - PyFrame::Charon => "IAU Body-Fixed Frame for Charon".to_string(), - PyFrame::Nix => "IAU Body-Fixed Frame for Nix".to_string(), - PyFrame::Hydra => "IAU Body-Fixed Frame for Hydra".to_string(), - PyFrame::Kerberos => "IAU Body-Fixed Frame for Kerberos".to_string(), - PyFrame::Styx => "IAU Body-Fixed Frame for Styx".to_string(), - PyFrame::Gaspra => "IAU Body-Fixed Frame for Gaspra".to_string(), - PyFrame::Ida => "IAU Body-Fixed Frame for Ida".to_string(), - PyFrame::Dactyl => "IAU Body-Fixed Frame for Dactyl".to_string(), - PyFrame::Ceres => "IAU Body-Fixed Frame for Ceres".to_string(), - PyFrame::Pallas => "IAU Body-Fixed Frame for Pallas".to_string(), - PyFrame::Vesta => "IAU Body-Fixed Frame for Vesta".to_string(), - PyFrame::Psyche => "IAU Body-Fixed Frame for Psyche".to_string(), - PyFrame::Lutetia => "IAU Body-Fixed Frame for Lutetia".to_string(), - PyFrame::Kleopatra => "IAU Body-Fixed Frame for Kleopatra".to_string(), - PyFrame::Eros => "IAU Body-Fixed Frame for Eros".to_string(), - PyFrame::Davida => "IAU Body-Fixed Frame for Davida".to_string(), - PyFrame::Mathilde => "IAU Body-Fixed Frame for Mathilde".to_string(), - PyFrame::Steins => "IAU Body-Fixed Frame for Steins".to_string(), - PyFrame::Braille => "IAU Body-Fixed Frame for Braille".to_string(), - PyFrame::WilsonHarrington => "IAU Body-Fixed Frame for Wilson-Harrington".to_string(), - PyFrame::Toutatis => "IAU Body-Fixed Frame for Toutatis".to_string(), - PyFrame::Itokawa => "IAU Body-Fixed Frame for Itokawa".to_string(), - PyFrame::Bennu => "IAU Body-Fixed Frame for Bennu".to_string(), - } - } - fn abbreviation(&self) -> String { - match self { - PyFrame::Icrf => "ICRF".to_string(), - PyFrame::Sun => "IAU_SUN".to_string(), - PyFrame::Mercury => "IAU_MERCURY".to_string(), - PyFrame::Venus => "IAU_VENUS".to_string(), - PyFrame::Earth => "IAU_EARTH".to_string(), - PyFrame::Mars => "IAU_MARS".to_string(), - PyFrame::Jupiter => "IAU_JUPITER".to_string(), - PyFrame::Saturn => "IAU_SATURN".to_string(), - PyFrame::Uranus => "IAU_URANUS".to_string(), - PyFrame::Neptune => "IAU_NEPTUNE".to_string(), - PyFrame::Pluto => "IAU_PLUTO".to_string(), - PyFrame::Moon => "IAU_MOON".to_string(), - PyFrame::Phobos => "IAU_PHOBOS".to_string(), - PyFrame::Deimos => "IAU_DEIMOS".to_string(), - PyFrame::Io => "IAU_IO".to_string(), - PyFrame::Europa => "IAU_EUROPA".to_string(), - PyFrame::Ganymede => "IAU_GANYMEDE".to_string(), - PyFrame::Callisto => "IAU_CALLISTO".to_string(), - PyFrame::Amalthea => "IAU_AMALTHEA".to_string(), - PyFrame::Himalia => "IAU_HIMALIA".to_string(), - PyFrame::Elara => "IAU_ELARA".to_string(), - PyFrame::Pasiphae => "IAU_PASIPHAE".to_string(), - PyFrame::Sinope => "IAU_SINOPE".to_string(), - PyFrame::Lysithea => "IAU_LYSITHEA".to_string(), - PyFrame::Carme => "IAU_CARME".to_string(), - PyFrame::Ananke => "IAU_ANANKE".to_string(), - PyFrame::Leda => "IAU_LEDA".to_string(), - PyFrame::Thebe => "IAU_THEBE".to_string(), - PyFrame::Adrastea => "IAU_ADRASTEA".to_string(), - PyFrame::Metis => "IAU_METIS".to_string(), - PyFrame::Callirrhoe => "IAU_CALLIRRHOE".to_string(), - PyFrame::Themisto => "IAU_THEMISTO".to_string(), - PyFrame::Magaclite => "IAU_MAGACLITE".to_string(), - PyFrame::Taygete => "IAU_TAYGETE".to_string(), - PyFrame::Chaldene => "IAU_CHALDENE".to_string(), - PyFrame::Harpalyke => "IAU_HARPALYKE".to_string(), - PyFrame::Kalyke => "IAU_KALYKE".to_string(), - PyFrame::Iocaste => "IAU_IOCASTE".to_string(), - PyFrame::Erinome => "IAU_ERINOME".to_string(), - PyFrame::Isonoe => "IAU_ISONOE".to_string(), - PyFrame::Praxidike => "IAU_PRAXIDIKE".to_string(), - PyFrame::Autonoe => "IAU_AUTONOE".to_string(), - PyFrame::Thyone => "IAU_THYONE".to_string(), - PyFrame::Hermippe => "IAU_HERMIPPE".to_string(), - PyFrame::Aitne => "IAU_AITNE".to_string(), - PyFrame::Eurydome => "IAU_EURYDOME".to_string(), - PyFrame::Euanthe => "IAU_EUANTHE".to_string(), - PyFrame::Euporie => "IAU_EUPORIE".to_string(), - PyFrame::Orthosie => "IAU_ORTHOSIE".to_string(), - PyFrame::Sponde => "IAU_SPONDE".to_string(), - PyFrame::Kale => "IAU_KALE".to_string(), - PyFrame::Pasithee => "IAU_PASITHEE".to_string(), - PyFrame::Hegemone => "IAU_HEGEMONE".to_string(), - PyFrame::Mneme => "IAU_MNEME".to_string(), - PyFrame::Aoede => "IAU_AOEDE".to_string(), - PyFrame::Thelxinoe => "IAU_THELXINOE".to_string(), - PyFrame::Arche => "IAU_ARCHE".to_string(), - PyFrame::Kallichore => "IAU_KALLICHORE".to_string(), - PyFrame::Helike => "IAU_HELIKE".to_string(), - PyFrame::Carpo => "IAU_CARPO".to_string(), - PyFrame::Eukelade => "IAU_EUKELADE".to_string(), - PyFrame::Cyllene => "IAU_CYLLENE".to_string(), - PyFrame::Kore => "IAU_KORE".to_string(), - PyFrame::Herse => "IAU_HERSE".to_string(), - PyFrame::Dia => "IAU_DIA".to_string(), - PyFrame::Mimas => "IAU_MIMAS".to_string(), - PyFrame::Enceladus => "IAU_ENCELADUS".to_string(), - PyFrame::Tethys => "IAU_TETHYS".to_string(), - PyFrame::Dione => "IAU_DIONE".to_string(), - PyFrame::Rhea => "IAU_RHEA".to_string(), - PyFrame::Titan => "IAU_TITAN".to_string(), - PyFrame::Hyperion => "IAU_HYPERION".to_string(), - PyFrame::Iapetus => "IAU_IAPETUS".to_string(), - PyFrame::Phoebe => "IAU_PHOEBE".to_string(), - PyFrame::Janus => "IAU_JANUS".to_string(), - PyFrame::Epimetheus => "IAU_EPIMETHEUS".to_string(), - PyFrame::Helene => "IAU_HELENE".to_string(), - PyFrame::Telesto => "IAU_TELESTO".to_string(), - PyFrame::Calypso => "IAU_CALYPSO".to_string(), - PyFrame::Atlas => "IAU_ATLAS".to_string(), - PyFrame::Prometheus => "IAU_PROMETHEUS".to_string(), - PyFrame::Pandora => "IAU_PANDORA".to_string(), - PyFrame::Pan => "IAU_PAN".to_string(), - PyFrame::Ymir => "IAU_YMIR".to_string(), - PyFrame::Paaliaq => "IAU_PAALIAQ".to_string(), - PyFrame::Tarvos => "IAU_TARVOS".to_string(), - PyFrame::Ijiraq => "IAU_IJIRAQ".to_string(), - PyFrame::Suttungr => "IAU_SUTTUNGR".to_string(), - PyFrame::Kiviuq => "IAU_KIVIUQ".to_string(), - PyFrame::Mundilfari => "IAU_MUNDILFARI".to_string(), - PyFrame::Albiorix => "IAU_ALBIORIX".to_string(), - PyFrame::Skathi => "IAU_SKATHI".to_string(), - PyFrame::Erriapus => "IAU_ERRIAPUS".to_string(), - PyFrame::Siarnaq => "IAU_SIARNAQ".to_string(), - PyFrame::Thrymr => "IAU_THRYMR".to_string(), - PyFrame::Narvi => "IAU_NARVI".to_string(), - PyFrame::Methone => "IAU_METHONE".to_string(), - PyFrame::Pallene => "IAU_PALLENE".to_string(), - PyFrame::Polydeuces => "IAU_POLYDEUCES".to_string(), - PyFrame::Daphnis => "IAU_DAPHNIS".to_string(), - PyFrame::Aegir => "IAU_AEGIR".to_string(), - PyFrame::Bebhionn => "IAU_BEBHIONN".to_string(), - PyFrame::Bergelmir => "IAU_BERGELMIR".to_string(), - PyFrame::Bestla => "IAU_BESTLA".to_string(), - PyFrame::Farbauti => "IAU_FARBAUTI".to_string(), - PyFrame::Fenrir => "IAU_FENRIR".to_string(), - PyFrame::Fornjot => "IAU_FORNJOT".to_string(), - PyFrame::Hati => "IAU_HATI".to_string(), - PyFrame::Hyrrokkin => "IAU_HYRROKKIN".to_string(), - PyFrame::Kari => "IAU_KARI".to_string(), - PyFrame::Loge => "IAU_LOGE".to_string(), - PyFrame::Skoll => "IAU_SKOLL".to_string(), - PyFrame::Surtur => "IAU_SURTUR".to_string(), - PyFrame::Anthe => "IAU_ANTHE".to_string(), - PyFrame::Jarnsaxa => "IAU_JARNSAXA".to_string(), - PyFrame::Greip => "IAU_GREIP".to_string(), - PyFrame::Tarqeq => "IAU_TARQEQ".to_string(), - PyFrame::Aegaeon => "IAU_AEGAEON".to_string(), - PyFrame::Ariel => "IAU_ARIEL".to_string(), - PyFrame::Umbriel => "IAU_UMBRIEL".to_string(), - PyFrame::Titania => "IAU_TITANIA".to_string(), - PyFrame::Oberon => "IAU_OBERON".to_string(), - PyFrame::Miranda => "IAU_MIRANDA".to_string(), - PyFrame::Cordelia => "IAU_CORDELIA".to_string(), - PyFrame::Ophelia => "IAU_OPHELIA".to_string(), - PyFrame::Bianca => "IAU_BIANCA".to_string(), - PyFrame::Cressida => "IAU_CRESSIDA".to_string(), - PyFrame::Desdemona => "IAU_DESDEMONA".to_string(), - PyFrame::Juliet => "IAU_JULIET".to_string(), - PyFrame::Portia => "IAU_PORTIA".to_string(), - PyFrame::Rosalind => "IAU_ROSALIND".to_string(), - PyFrame::Belinda => "IAU_BELINDA".to_string(), - PyFrame::Puck => "IAU_PUCK".to_string(), - PyFrame::Caliban => "IAU_CALIBAN".to_string(), - PyFrame::Sycorax => "IAU_SYCORAX".to_string(), - PyFrame::Prospero => "IAU_PROSPERO".to_string(), - PyFrame::Setebos => "IAU_SETEBOS".to_string(), - PyFrame::Stephano => "IAU_STEPHANO".to_string(), - PyFrame::Trinculo => "IAU_TRINCULO".to_string(), - PyFrame::Francisco => "IAU_FRANCISCO".to_string(), - PyFrame::Margaret => "IAU_MARGARET".to_string(), - PyFrame::Ferdinand => "IAU_FERDINAND".to_string(), - PyFrame::Perdita => "IAU_PERDITA".to_string(), - PyFrame::Mab => "IAU_MAB".to_string(), - PyFrame::Cupid => "IAU_CUPID".to_string(), - PyFrame::Triton => "IAU_TRITON".to_string(), - PyFrame::Nereid => "IAU_NEREID".to_string(), - PyFrame::Naiad => "IAU_NAIAD".to_string(), - PyFrame::Thalassa => "IAU_THALASSA".to_string(), - PyFrame::Despina => "IAU_DESPINA".to_string(), - PyFrame::Galatea => "IAU_GALATEA".to_string(), - PyFrame::Larissa => "IAU_LARISSA".to_string(), - PyFrame::Proteus => "IAU_PROTEUS".to_string(), - PyFrame::Halimede => "IAU_HALIMEDE".to_string(), - PyFrame::Psamathe => "IAU_PSAMATHE".to_string(), - PyFrame::Sao => "IAU_SAO".to_string(), - PyFrame::Laomedeia => "IAU_LAOMEDEIA".to_string(), - PyFrame::Neso => "IAU_NESO".to_string(), - PyFrame::Charon => "IAU_CHARON".to_string(), - PyFrame::Nix => "IAU_NIX".to_string(), - PyFrame::Hydra => "IAU_HYDRA".to_string(), - PyFrame::Kerberos => "IAU_KERBEROS".to_string(), - PyFrame::Styx => "IAU_STYX".to_string(), - PyFrame::Gaspra => "IAU_GASPRA".to_string(), - PyFrame::Ida => "IAU_IDA".to_string(), - PyFrame::Dactyl => "IAU_DACTYL".to_string(), - PyFrame::Ceres => "IAU_CERES".to_string(), - PyFrame::Pallas => "IAU_PALLAS".to_string(), - PyFrame::Vesta => "IAU_VESTA".to_string(), - PyFrame::Psyche => "IAU_PSYCHE".to_string(), - PyFrame::Lutetia => "IAU_LUTETIA".to_string(), - PyFrame::Kleopatra => "IAU_KLEOPATRA".to_string(), - PyFrame::Eros => "IAU_EROS".to_string(), - PyFrame::Davida => "IAU_DAVIDA".to_string(), - PyFrame::Mathilde => "IAU_MATHILDE".to_string(), - PyFrame::Steins => "IAU_STEINS".to_string(), - PyFrame::Braille => "IAU_BRAILLE".to_string(), - PyFrame::WilsonHarrington => "IAU_WILSON_HARRINGTON".to_string(), - PyFrame::Toutatis => "IAU_TOUTATIS".to_string(), - PyFrame::Itokawa => "IAU_ITOKAWA".to_string(), - PyFrame::Bennu => "IAU_BENNU".to_string(), - } - } -} -impl FromStr for PyFrame { - type Err = PyErr; - fn from_str(s: &str) -> Result { - match s { - "ICRF" | "icrf" => Ok(PyFrame::Icrf), - "IAU_SUN" | "iau_sun" => Ok(PyFrame::Sun), - "IAU_MERCURY" | "iau_mercury" => Ok(PyFrame::Mercury), - "IAU_VENUS" | "iau_venus" => Ok(PyFrame::Venus), - "IAU_EARTH" | "iau_earth" => Ok(PyFrame::Earth), - "IAU_MARS" | "iau_mars" => Ok(PyFrame::Mars), - "IAU_JUPITER" | "iau_jupiter" => Ok(PyFrame::Jupiter), - "IAU_SATURN" | "iau_saturn" => Ok(PyFrame::Saturn), - "IAU_URANUS" | "iau_uranus" => Ok(PyFrame::Uranus), - "IAU_NEPTUNE" | "iau_neptune" => Ok(PyFrame::Neptune), - "IAU_PLUTO" | "iau_pluto" => Ok(PyFrame::Pluto), - "IAU_MOON" | "iau_moon" => Ok(PyFrame::Moon), - "IAU_PHOBOS" | "iau_phobos" => Ok(PyFrame::Phobos), - "IAU_DEIMOS" | "iau_deimos" => Ok(PyFrame::Deimos), - "IAU_IO" | "iau_io" => Ok(PyFrame::Io), - "IAU_EUROPA" | "iau_europa" => Ok(PyFrame::Europa), - "IAU_GANYMEDE" | "iau_ganymede" => Ok(PyFrame::Ganymede), - "IAU_CALLISTO" | "iau_callisto" => Ok(PyFrame::Callisto), - "IAU_AMALTHEA" | "iau_amalthea" => Ok(PyFrame::Amalthea), - "IAU_HIMALIA" | "iau_himalia" => Ok(PyFrame::Himalia), - "IAU_ELARA" | "iau_elara" => Ok(PyFrame::Elara), - "IAU_PASIPHAE" | "iau_pasiphae" => Ok(PyFrame::Pasiphae), - "IAU_SINOPE" | "iau_sinope" => Ok(PyFrame::Sinope), - "IAU_LYSITHEA" | "iau_lysithea" => Ok(PyFrame::Lysithea), - "IAU_CARME" | "iau_carme" => Ok(PyFrame::Carme), - "IAU_ANANKE" | "iau_ananke" => Ok(PyFrame::Ananke), - "IAU_LEDA" | "iau_leda" => Ok(PyFrame::Leda), - "IAU_THEBE" | "iau_thebe" => Ok(PyFrame::Thebe), - "IAU_ADRASTEA" | "iau_adrastea" => Ok(PyFrame::Adrastea), - "IAU_METIS" | "iau_metis" => Ok(PyFrame::Metis), - "IAU_CALLIRRHOE" | "iau_callirrhoe" => Ok(PyFrame::Callirrhoe), - "IAU_THEMISTO" | "iau_themisto" => Ok(PyFrame::Themisto), - "IAU_MAGACLITE" | "iau_magaclite" => Ok(PyFrame::Magaclite), - "IAU_TAYGETE" | "iau_taygete" => Ok(PyFrame::Taygete), - "IAU_CHALDENE" | "iau_chaldene" => Ok(PyFrame::Chaldene), - "IAU_HARPALYKE" | "iau_harpalyke" => Ok(PyFrame::Harpalyke), - "IAU_KALYKE" | "iau_kalyke" => Ok(PyFrame::Kalyke), - "IAU_IOCASTE" | "iau_iocaste" => Ok(PyFrame::Iocaste), - "IAU_ERINOME" | "iau_erinome" => Ok(PyFrame::Erinome), - "IAU_ISONOE" | "iau_isonoe" => Ok(PyFrame::Isonoe), - "IAU_PRAXIDIKE" | "iau_praxidike" => Ok(PyFrame::Praxidike), - "IAU_AUTONOE" | "iau_autonoe" => Ok(PyFrame::Autonoe), - "IAU_THYONE" | "iau_thyone" => Ok(PyFrame::Thyone), - "IAU_HERMIPPE" | "iau_hermippe" => Ok(PyFrame::Hermippe), - "IAU_AITNE" | "iau_aitne" => Ok(PyFrame::Aitne), - "IAU_EURYDOME" | "iau_eurydome" => Ok(PyFrame::Eurydome), - "IAU_EUANTHE" | "iau_euanthe" => Ok(PyFrame::Euanthe), - "IAU_EUPORIE" | "iau_euporie" => Ok(PyFrame::Euporie), - "IAU_ORTHOSIE" | "iau_orthosie" => Ok(PyFrame::Orthosie), - "IAU_SPONDE" | "iau_sponde" => Ok(PyFrame::Sponde), - "IAU_KALE" | "iau_kale" => Ok(PyFrame::Kale), - "IAU_PASITHEE" | "iau_pasithee" => Ok(PyFrame::Pasithee), - "IAU_HEGEMONE" | "iau_hegemone" => Ok(PyFrame::Hegemone), - "IAU_MNEME" | "iau_mneme" => Ok(PyFrame::Mneme), - "IAU_AOEDE" | "iau_aoede" => Ok(PyFrame::Aoede), - "IAU_THELXINOE" | "iau_thelxinoe" => Ok(PyFrame::Thelxinoe), - "IAU_ARCHE" | "iau_arche" => Ok(PyFrame::Arche), - "IAU_KALLICHORE" | "iau_kallichore" => Ok(PyFrame::Kallichore), - "IAU_HELIKE" | "iau_helike" => Ok(PyFrame::Helike), - "IAU_CARPO" | "iau_carpo" => Ok(PyFrame::Carpo), - "IAU_EUKELADE" | "iau_eukelade" => Ok(PyFrame::Eukelade), - "IAU_CYLLENE" | "iau_cyllene" => Ok(PyFrame::Cyllene), - "IAU_KORE" | "iau_kore" => Ok(PyFrame::Kore), - "IAU_HERSE" | "iau_herse" => Ok(PyFrame::Herse), - "IAU_DIA" | "iau_dia" => Ok(PyFrame::Dia), - "IAU_MIMAS" | "iau_mimas" => Ok(PyFrame::Mimas), - "IAU_ENCELADUS" | "iau_enceladus" => Ok(PyFrame::Enceladus), - "IAU_TETHYS" | "iau_tethys" => Ok(PyFrame::Tethys), - "IAU_DIONE" | "iau_dione" => Ok(PyFrame::Dione), - "IAU_RHEA" | "iau_rhea" => Ok(PyFrame::Rhea), - "IAU_TITAN" | "iau_titan" => Ok(PyFrame::Titan), - "IAU_HYPERION" | "iau_hyperion" => Ok(PyFrame::Hyperion), - "IAU_IAPETUS" | "iau_iapetus" => Ok(PyFrame::Iapetus), - "IAU_PHOEBE" | "iau_phoebe" => Ok(PyFrame::Phoebe), - "IAU_JANUS" | "iau_janus" => Ok(PyFrame::Janus), - "IAU_EPIMETHEUS" | "iau_epimetheus" => Ok(PyFrame::Epimetheus), - "IAU_HELENE" | "iau_helene" => Ok(PyFrame::Helene), - "IAU_TELESTO" | "iau_telesto" => Ok(PyFrame::Telesto), - "IAU_CALYPSO" | "iau_calypso" => Ok(PyFrame::Calypso), - "IAU_ATLAS" | "iau_atlas" => Ok(PyFrame::Atlas), - "IAU_PROMETHEUS" | "iau_prometheus" => Ok(PyFrame::Prometheus), - "IAU_PANDORA" | "iau_pandora" => Ok(PyFrame::Pandora), - "IAU_PAN" | "iau_pan" => Ok(PyFrame::Pan), - "IAU_YMIR" | "iau_ymir" => Ok(PyFrame::Ymir), - "IAU_PAALIAQ" | "iau_paaliaq" => Ok(PyFrame::Paaliaq), - "IAU_TARVOS" | "iau_tarvos" => Ok(PyFrame::Tarvos), - "IAU_IJIRAQ" | "iau_ijiraq" => Ok(PyFrame::Ijiraq), - "IAU_SUTTUNGR" | "iau_suttungr" => Ok(PyFrame::Suttungr), - "IAU_KIVIUQ" | "iau_kiviuq" => Ok(PyFrame::Kiviuq), - "IAU_MUNDILFARI" | "iau_mundilfari" => Ok(PyFrame::Mundilfari), - "IAU_ALBIORIX" | "iau_albiorix" => Ok(PyFrame::Albiorix), - "IAU_SKATHI" | "iau_skathi" => Ok(PyFrame::Skathi), - "IAU_ERRIAPUS" | "iau_erriapus" => Ok(PyFrame::Erriapus), - "IAU_SIARNAQ" | "iau_siarnaq" => Ok(PyFrame::Siarnaq), - "IAU_THRYMR" | "iau_thrymr" => Ok(PyFrame::Thrymr), - "IAU_NARVI" | "iau_narvi" => Ok(PyFrame::Narvi), - "IAU_METHONE" | "iau_methone" => Ok(PyFrame::Methone), - "IAU_PALLENE" | "iau_pallene" => Ok(PyFrame::Pallene), - "IAU_POLYDEUCES" | "iau_polydeuces" => Ok(PyFrame::Polydeuces), - "IAU_DAPHNIS" | "iau_daphnis" => Ok(PyFrame::Daphnis), - "IAU_AEGIR" | "iau_aegir" => Ok(PyFrame::Aegir), - "IAU_BEBHIONN" | "iau_bebhionn" => Ok(PyFrame::Bebhionn), - "IAU_BERGELMIR" | "iau_bergelmir" => Ok(PyFrame::Bergelmir), - "IAU_BESTLA" | "iau_bestla" => Ok(PyFrame::Bestla), - "IAU_FARBAUTI" | "iau_farbauti" => Ok(PyFrame::Farbauti), - "IAU_FENRIR" | "iau_fenrir" => Ok(PyFrame::Fenrir), - "IAU_FORNJOT" | "iau_fornjot" => Ok(PyFrame::Fornjot), - "IAU_HATI" | "iau_hati" => Ok(PyFrame::Hati), - "IAU_HYRROKKIN" | "iau_hyrrokkin" => Ok(PyFrame::Hyrrokkin), - "IAU_KARI" | "iau_kari" => Ok(PyFrame::Kari), - "IAU_LOGE" | "iau_loge" => Ok(PyFrame::Loge), - "IAU_SKOLL" | "iau_skoll" => Ok(PyFrame::Skoll), - "IAU_SURTUR" | "iau_surtur" => Ok(PyFrame::Surtur), - "IAU_ANTHE" | "iau_anthe" => Ok(PyFrame::Anthe), - "IAU_JARNSAXA" | "iau_jarnsaxa" => Ok(PyFrame::Jarnsaxa), - "IAU_GREIP" | "iau_greip" => Ok(PyFrame::Greip), - "IAU_TARQEQ" | "iau_tarqeq" => Ok(PyFrame::Tarqeq), - "IAU_AEGAEON" | "iau_aegaeon" => Ok(PyFrame::Aegaeon), - "IAU_ARIEL" | "iau_ariel" => Ok(PyFrame::Ariel), - "IAU_UMBRIEL" | "iau_umbriel" => Ok(PyFrame::Umbriel), - "IAU_TITANIA" | "iau_titania" => Ok(PyFrame::Titania), - "IAU_OBERON" | "iau_oberon" => Ok(PyFrame::Oberon), - "IAU_MIRANDA" | "iau_miranda" => Ok(PyFrame::Miranda), - "IAU_CORDELIA" | "iau_cordelia" => Ok(PyFrame::Cordelia), - "IAU_OPHELIA" | "iau_ophelia" => Ok(PyFrame::Ophelia), - "IAU_BIANCA" | "iau_bianca" => Ok(PyFrame::Bianca), - "IAU_CRESSIDA" | "iau_cressida" => Ok(PyFrame::Cressida), - "IAU_DESDEMONA" | "iau_desdemona" => Ok(PyFrame::Desdemona), - "IAU_JULIET" | "iau_juliet" => Ok(PyFrame::Juliet), - "IAU_PORTIA" | "iau_portia" => Ok(PyFrame::Portia), - "IAU_ROSALIND" | "iau_rosalind" => Ok(PyFrame::Rosalind), - "IAU_BELINDA" | "iau_belinda" => Ok(PyFrame::Belinda), - "IAU_PUCK" | "iau_puck" => Ok(PyFrame::Puck), - "IAU_CALIBAN" | "iau_caliban" => Ok(PyFrame::Caliban), - "IAU_SYCORAX" | "iau_sycorax" => Ok(PyFrame::Sycorax), - "IAU_PROSPERO" | "iau_prospero" => Ok(PyFrame::Prospero), - "IAU_SETEBOS" | "iau_setebos" => Ok(PyFrame::Setebos), - "IAU_STEPHANO" | "iau_stephano" => Ok(PyFrame::Stephano), - "IAU_TRINCULO" | "iau_trinculo" => Ok(PyFrame::Trinculo), - "IAU_FRANCISCO" | "iau_francisco" => Ok(PyFrame::Francisco), - "IAU_MARGARET" | "iau_margaret" => Ok(PyFrame::Margaret), - "IAU_FERDINAND" | "iau_ferdinand" => Ok(PyFrame::Ferdinand), - "IAU_PERDITA" | "iau_perdita" => Ok(PyFrame::Perdita), - "IAU_MAB" | "iau_mab" => Ok(PyFrame::Mab), - "IAU_CUPID" | "iau_cupid" => Ok(PyFrame::Cupid), - "IAU_TRITON" | "iau_triton" => Ok(PyFrame::Triton), - "IAU_NEREID" | "iau_nereid" => Ok(PyFrame::Nereid), - "IAU_NAIAD" | "iau_naiad" => Ok(PyFrame::Naiad), - "IAU_THALASSA" | "iau_thalassa" => Ok(PyFrame::Thalassa), - "IAU_DESPINA" | "iau_despina" => Ok(PyFrame::Despina), - "IAU_GALATEA" | "iau_galatea" => Ok(PyFrame::Galatea), - "IAU_LARISSA" | "iau_larissa" => Ok(PyFrame::Larissa), - "IAU_PROTEUS" | "iau_proteus" => Ok(PyFrame::Proteus), - "IAU_HALIMEDE" | "iau_halimede" => Ok(PyFrame::Halimede), - "IAU_PSAMATHE" | "iau_psamathe" => Ok(PyFrame::Psamathe), - "IAU_SAO" | "iau_sao" => Ok(PyFrame::Sao), - "IAU_LAOMEDEIA" | "iau_laomedeia" => Ok(PyFrame::Laomedeia), - "IAU_NESO" | "iau_neso" => Ok(PyFrame::Neso), - "IAU_CHARON" | "iau_charon" => Ok(PyFrame::Charon), - "IAU_NIX" | "iau_nix" => Ok(PyFrame::Nix), - "IAU_HYDRA" | "iau_hydra" => Ok(PyFrame::Hydra), - "IAU_KERBEROS" | "iau_kerberos" => Ok(PyFrame::Kerberos), - "IAU_STYX" | "iau_styx" => Ok(PyFrame::Styx), - "IAU_GASPRA" | "iau_gaspra" => Ok(PyFrame::Gaspra), - "IAU_IDA" | "iau_ida" => Ok(PyFrame::Ida), - "IAU_DACTYL" | "iau_dactyl" => Ok(PyFrame::Dactyl), - "IAU_CERES" | "iau_ceres" => Ok(PyFrame::Ceres), - "IAU_PALLAS" | "iau_pallas" => Ok(PyFrame::Pallas), - "IAU_VESTA" | "iau_vesta" => Ok(PyFrame::Vesta), - "IAU_PSYCHE" | "iau_psyche" => Ok(PyFrame::Psyche), - "IAU_LUTETIA" | "iau_lutetia" => Ok(PyFrame::Lutetia), - "IAU_KLEOPATRA" | "iau_kleopatra" => Ok(PyFrame::Kleopatra), - "IAU_EROS" | "iau_eros" => Ok(PyFrame::Eros), - "IAU_DAVIDA" | "iau_davida" => Ok(PyFrame::Davida), - "IAU_MATHILDE" | "iau_mathilde" => Ok(PyFrame::Mathilde), - "IAU_STEINS" | "iau_steins" => Ok(PyFrame::Steins), - "IAU_BRAILLE" | "iau_braille" => Ok(PyFrame::Braille), - "IAU_WILSON_HARRINGTON" | "iau_wilson_harrington" => Ok(PyFrame::WilsonHarrington), - "IAU_TOUTATIS" | "iau_toutatis" => Ok(PyFrame::Toutatis), - "IAU_ITOKAWA" | "iau_itokawa" => Ok(PyFrame::Itokawa), - "IAU_BENNU" | "iau_bennu" => Ok(PyFrame::Bennu), - _ => Err(PyValueError::new_err("unknown reference frame")), - } - } -} -#[cfg(test)] -#[allow(clippy::approx_constant)] -mod tests { - use super::*; - #[test] - fn test_reference_frame_icrf() { - assert_eq!( - PyFrame::Icrf.name(), - "International Celestial Reference Frame" - ); - assert_eq!(PyFrame::Icrf.abbreviation(), "ICRF"); - } - #[test] - fn test_reference_frame_iau_sun() { - assert_eq!(PyFrame::Sun.name(), "IAU Body-Fixed Frame for the Sun"); - assert_eq!(PyFrame::Sun.abbreviation(), "IAU_SUN"); - } - #[test] - fn test_reference_frame_iau_mercury() { - assert_eq!(PyFrame::Mercury.name(), "IAU Body-Fixed Frame for Mercury"); - assert_eq!(PyFrame::Mercury.abbreviation(), "IAU_MERCURY"); - } - #[test] - fn test_reference_frame_iau_venus() { - assert_eq!(PyFrame::Venus.name(), "IAU Body-Fixed Frame for Venus"); - assert_eq!(PyFrame::Venus.abbreviation(), "IAU_VENUS"); - } - #[test] - fn test_reference_frame_iau_earth() { - assert_eq!(PyFrame::Earth.name(), "IAU Body-Fixed Frame for Earth"); - assert_eq!(PyFrame::Earth.abbreviation(), "IAU_EARTH"); - } - #[test] - fn test_reference_frame_iau_mars() { - assert_eq!(PyFrame::Mars.name(), "IAU Body-Fixed Frame for Mars"); - assert_eq!(PyFrame::Mars.abbreviation(), "IAU_MARS"); - } - #[test] - fn test_reference_frame_iau_jupiter() { - assert_eq!(PyFrame::Jupiter.name(), "IAU Body-Fixed Frame for Jupiter"); - assert_eq!(PyFrame::Jupiter.abbreviation(), "IAU_JUPITER"); - } - #[test] - fn test_reference_frame_iau_saturn() { - assert_eq!(PyFrame::Saturn.name(), "IAU Body-Fixed Frame for Saturn"); - assert_eq!(PyFrame::Saturn.abbreviation(), "IAU_SATURN"); - } - #[test] - fn test_reference_frame_iau_uranus() { - assert_eq!(PyFrame::Uranus.name(), "IAU Body-Fixed Frame for Uranus"); - assert_eq!(PyFrame::Uranus.abbreviation(), "IAU_URANUS"); - } - #[test] - fn test_reference_frame_iau_neptune() { - assert_eq!(PyFrame::Neptune.name(), "IAU Body-Fixed Frame for Neptune"); - assert_eq!(PyFrame::Neptune.abbreviation(), "IAU_NEPTUNE"); - } - #[test] - fn test_reference_frame_iau_pluto() { - assert_eq!(PyFrame::Pluto.name(), "IAU Body-Fixed Frame for Pluto"); - assert_eq!(PyFrame::Pluto.abbreviation(), "IAU_PLUTO"); - } - #[test] - fn test_reference_frame_iau_moon() { - assert_eq!(PyFrame::Moon.name(), "IAU Body-Fixed Frame for the Moon"); - assert_eq!(PyFrame::Moon.abbreviation(), "IAU_MOON"); - } - #[test] - fn test_reference_frame_iau_phobos() { - assert_eq!(PyFrame::Phobos.name(), "IAU Body-Fixed Frame for Phobos"); - assert_eq!(PyFrame::Phobos.abbreviation(), "IAU_PHOBOS"); - } - #[test] - fn test_reference_frame_iau_deimos() { - assert_eq!(PyFrame::Deimos.name(), "IAU Body-Fixed Frame for Deimos"); - assert_eq!(PyFrame::Deimos.abbreviation(), "IAU_DEIMOS"); - } - #[test] - fn test_reference_frame_iau_io() { - assert_eq!(PyFrame::Io.name(), "IAU Body-Fixed Frame for Io"); - assert_eq!(PyFrame::Io.abbreviation(), "IAU_IO"); - } - #[test] - fn test_reference_frame_iau_europa() { - assert_eq!(PyFrame::Europa.name(), "IAU Body-Fixed Frame for Europa"); - assert_eq!(PyFrame::Europa.abbreviation(), "IAU_EUROPA"); - } - #[test] - fn test_reference_frame_iau_ganymede() { - assert_eq!( - PyFrame::Ganymede.name(), - "IAU Body-Fixed Frame for Ganymede" - ); - assert_eq!(PyFrame::Ganymede.abbreviation(), "IAU_GANYMEDE"); - } - #[test] - fn test_reference_frame_iau_callisto() { - assert_eq!( - PyFrame::Callisto.name(), - "IAU Body-Fixed Frame for Callisto" - ); - assert_eq!(PyFrame::Callisto.abbreviation(), "IAU_CALLISTO"); - } - #[test] - fn test_reference_frame_iau_amalthea() { - assert_eq!( - PyFrame::Amalthea.name(), - "IAU Body-Fixed Frame for Amalthea" - ); - assert_eq!(PyFrame::Amalthea.abbreviation(), "IAU_AMALTHEA"); - } - #[test] - fn test_reference_frame_iau_himalia() { - assert_eq!(PyFrame::Himalia.name(), "IAU Body-Fixed Frame for Himalia"); - assert_eq!(PyFrame::Himalia.abbreviation(), "IAU_HIMALIA"); - } - #[test] - fn test_reference_frame_iau_elara() { - assert_eq!(PyFrame::Elara.name(), "IAU Body-Fixed Frame for Elara"); - assert_eq!(PyFrame::Elara.abbreviation(), "IAU_ELARA"); - } - #[test] - fn test_reference_frame_iau_pasiphae() { - assert_eq!( - PyFrame::Pasiphae.name(), - "IAU Body-Fixed Frame for Pasiphae" - ); - assert_eq!(PyFrame::Pasiphae.abbreviation(), "IAU_PASIPHAE"); - } - #[test] - fn test_reference_frame_iau_sinope() { - assert_eq!(PyFrame::Sinope.name(), "IAU Body-Fixed Frame for Sinope"); - assert_eq!(PyFrame::Sinope.abbreviation(), "IAU_SINOPE"); - } - #[test] - fn test_reference_frame_iau_lysithea() { - assert_eq!( - PyFrame::Lysithea.name(), - "IAU Body-Fixed Frame for Lysithea" - ); - assert_eq!(PyFrame::Lysithea.abbreviation(), "IAU_LYSITHEA"); - } - #[test] - fn test_reference_frame_iau_carme() { - assert_eq!(PyFrame::Carme.name(), "IAU Body-Fixed Frame for Carme"); - assert_eq!(PyFrame::Carme.abbreviation(), "IAU_CARME"); - } - #[test] - fn test_reference_frame_iau_ananke() { - assert_eq!(PyFrame::Ananke.name(), "IAU Body-Fixed Frame for Ananke"); - assert_eq!(PyFrame::Ananke.abbreviation(), "IAU_ANANKE"); - } - #[test] - fn test_reference_frame_iau_leda() { - assert_eq!(PyFrame::Leda.name(), "IAU Body-Fixed Frame for Leda"); - assert_eq!(PyFrame::Leda.abbreviation(), "IAU_LEDA"); - } - #[test] - fn test_reference_frame_iau_thebe() { - assert_eq!(PyFrame::Thebe.name(), "IAU Body-Fixed Frame for Thebe"); - assert_eq!(PyFrame::Thebe.abbreviation(), "IAU_THEBE"); - } - #[test] - fn test_reference_frame_iau_adrastea() { - assert_eq!( - PyFrame::Adrastea.name(), - "IAU Body-Fixed Frame for Adrastea" - ); - assert_eq!(PyFrame::Adrastea.abbreviation(), "IAU_ADRASTEA"); - } - #[test] - fn test_reference_frame_iau_metis() { - assert_eq!(PyFrame::Metis.name(), "IAU Body-Fixed Frame for Metis"); - assert_eq!(PyFrame::Metis.abbreviation(), "IAU_METIS"); - } - #[test] - fn test_reference_frame_iau_callirrhoe() { - assert_eq!( - PyFrame::Callirrhoe.name(), - "IAU Body-Fixed Frame for Callirrhoe" - ); - assert_eq!(PyFrame::Callirrhoe.abbreviation(), "IAU_CALLIRRHOE"); - } - #[test] - fn test_reference_frame_iau_themisto() { - assert_eq!( - PyFrame::Themisto.name(), - "IAU Body-Fixed Frame for Themisto" - ); - assert_eq!(PyFrame::Themisto.abbreviation(), "IAU_THEMISTO"); - } - #[test] - fn test_reference_frame_iau_magaclite() { - assert_eq!( - PyFrame::Magaclite.name(), - "IAU Body-Fixed Frame for Magaclite" - ); - assert_eq!(PyFrame::Magaclite.abbreviation(), "IAU_MAGACLITE"); - } - #[test] - fn test_reference_frame_iau_taygete() { - assert_eq!(PyFrame::Taygete.name(), "IAU Body-Fixed Frame for Taygete"); - assert_eq!(PyFrame::Taygete.abbreviation(), "IAU_TAYGETE"); - } - #[test] - fn test_reference_frame_iau_chaldene() { - assert_eq!( - PyFrame::Chaldene.name(), - "IAU Body-Fixed Frame for Chaldene" - ); - assert_eq!(PyFrame::Chaldene.abbreviation(), "IAU_CHALDENE"); - } - #[test] - fn test_reference_frame_iau_harpalyke() { - assert_eq!( - PyFrame::Harpalyke.name(), - "IAU Body-Fixed Frame for Harpalyke" - ); - assert_eq!(PyFrame::Harpalyke.abbreviation(), "IAU_HARPALYKE"); - } - #[test] - fn test_reference_frame_iau_kalyke() { - assert_eq!(PyFrame::Kalyke.name(), "IAU Body-Fixed Frame for Kalyke"); - assert_eq!(PyFrame::Kalyke.abbreviation(), "IAU_KALYKE"); - } - #[test] - fn test_reference_frame_iau_iocaste() { - assert_eq!(PyFrame::Iocaste.name(), "IAU Body-Fixed Frame for Iocaste"); - assert_eq!(PyFrame::Iocaste.abbreviation(), "IAU_IOCASTE"); - } - #[test] - fn test_reference_frame_iau_erinome() { - assert_eq!(PyFrame::Erinome.name(), "IAU Body-Fixed Frame for Erinome"); - assert_eq!(PyFrame::Erinome.abbreviation(), "IAU_ERINOME"); - } - #[test] - fn test_reference_frame_iau_isonoe() { - assert_eq!(PyFrame::Isonoe.name(), "IAU Body-Fixed Frame for Isonoe"); - assert_eq!(PyFrame::Isonoe.abbreviation(), "IAU_ISONOE"); - } - #[test] - fn test_reference_frame_iau_praxidike() { - assert_eq!( - PyFrame::Praxidike.name(), - "IAU Body-Fixed Frame for Praxidike" - ); - assert_eq!(PyFrame::Praxidike.abbreviation(), "IAU_PRAXIDIKE"); - } - #[test] - fn test_reference_frame_iau_autonoe() { - assert_eq!(PyFrame::Autonoe.name(), "IAU Body-Fixed Frame for Autonoe"); - assert_eq!(PyFrame::Autonoe.abbreviation(), "IAU_AUTONOE"); - } - #[test] - fn test_reference_frame_iau_thyone() { - assert_eq!(PyFrame::Thyone.name(), "IAU Body-Fixed Frame for Thyone"); - assert_eq!(PyFrame::Thyone.abbreviation(), "IAU_THYONE"); - } - #[test] - fn test_reference_frame_iau_hermippe() { - assert_eq!( - PyFrame::Hermippe.name(), - "IAU Body-Fixed Frame for Hermippe" - ); - assert_eq!(PyFrame::Hermippe.abbreviation(), "IAU_HERMIPPE"); - } - #[test] - fn test_reference_frame_iau_aitne() { - assert_eq!(PyFrame::Aitne.name(), "IAU Body-Fixed Frame for Aitne"); - assert_eq!(PyFrame::Aitne.abbreviation(), "IAU_AITNE"); - } - #[test] - fn test_reference_frame_iau_eurydome() { - assert_eq!( - PyFrame::Eurydome.name(), - "IAU Body-Fixed Frame for Eurydome" - ); - assert_eq!(PyFrame::Eurydome.abbreviation(), "IAU_EURYDOME"); - } - #[test] - fn test_reference_frame_iau_euanthe() { - assert_eq!(PyFrame::Euanthe.name(), "IAU Body-Fixed Frame for Euanthe"); - assert_eq!(PyFrame::Euanthe.abbreviation(), "IAU_EUANTHE"); - } - #[test] - fn test_reference_frame_iau_euporie() { - assert_eq!(PyFrame::Euporie.name(), "IAU Body-Fixed Frame for Euporie"); - assert_eq!(PyFrame::Euporie.abbreviation(), "IAU_EUPORIE"); - } - #[test] - fn test_reference_frame_iau_orthosie() { - assert_eq!( - PyFrame::Orthosie.name(), - "IAU Body-Fixed Frame for Orthosie" - ); - assert_eq!(PyFrame::Orthosie.abbreviation(), "IAU_ORTHOSIE"); - } - #[test] - fn test_reference_frame_iau_sponde() { - assert_eq!(PyFrame::Sponde.name(), "IAU Body-Fixed Frame for Sponde"); - assert_eq!(PyFrame::Sponde.abbreviation(), "IAU_SPONDE"); - } - #[test] - fn test_reference_frame_iau_kale() { - assert_eq!(PyFrame::Kale.name(), "IAU Body-Fixed Frame for Kale"); - assert_eq!(PyFrame::Kale.abbreviation(), "IAU_KALE"); - } - #[test] - fn test_reference_frame_iau_pasithee() { - assert_eq!( - PyFrame::Pasithee.name(), - "IAU Body-Fixed Frame for Pasithee" - ); - assert_eq!(PyFrame::Pasithee.abbreviation(), "IAU_PASITHEE"); - } - #[test] - fn test_reference_frame_iau_hegemone() { - assert_eq!( - PyFrame::Hegemone.name(), - "IAU Body-Fixed Frame for Hegemone" - ); - assert_eq!(PyFrame::Hegemone.abbreviation(), "IAU_HEGEMONE"); - } - #[test] - fn test_reference_frame_iau_mneme() { - assert_eq!(PyFrame::Mneme.name(), "IAU Body-Fixed Frame for Mneme"); - assert_eq!(PyFrame::Mneme.abbreviation(), "IAU_MNEME"); - } - #[test] - fn test_reference_frame_iau_aoede() { - assert_eq!(PyFrame::Aoede.name(), "IAU Body-Fixed Frame for Aoede"); - assert_eq!(PyFrame::Aoede.abbreviation(), "IAU_AOEDE"); - } - #[test] - fn test_reference_frame_iau_thelxinoe() { - assert_eq!( - PyFrame::Thelxinoe.name(), - "IAU Body-Fixed Frame for Thelxinoe" - ); - assert_eq!(PyFrame::Thelxinoe.abbreviation(), "IAU_THELXINOE"); - } - #[test] - fn test_reference_frame_iau_arche() { - assert_eq!(PyFrame::Arche.name(), "IAU Body-Fixed Frame for Arche"); - assert_eq!(PyFrame::Arche.abbreviation(), "IAU_ARCHE"); - } - #[test] - fn test_reference_frame_iau_kallichore() { - assert_eq!( - PyFrame::Kallichore.name(), - "IAU Body-Fixed Frame for Kallichore" - ); - assert_eq!(PyFrame::Kallichore.abbreviation(), "IAU_KALLICHORE"); - } - #[test] - fn test_reference_frame_iau_helike() { - assert_eq!(PyFrame::Helike.name(), "IAU Body-Fixed Frame for Helike"); - assert_eq!(PyFrame::Helike.abbreviation(), "IAU_HELIKE"); - } - #[test] - fn test_reference_frame_iau_carpo() { - assert_eq!(PyFrame::Carpo.name(), "IAU Body-Fixed Frame for Carpo"); - assert_eq!(PyFrame::Carpo.abbreviation(), "IAU_CARPO"); - } - #[test] - fn test_reference_frame_iau_eukelade() { - assert_eq!( - PyFrame::Eukelade.name(), - "IAU Body-Fixed Frame for Eukelade" - ); - assert_eq!(PyFrame::Eukelade.abbreviation(), "IAU_EUKELADE"); - } - #[test] - fn test_reference_frame_iau_cyllene() { - assert_eq!(PyFrame::Cyllene.name(), "IAU Body-Fixed Frame for Cyllene"); - assert_eq!(PyFrame::Cyllene.abbreviation(), "IAU_CYLLENE"); - } - #[test] - fn test_reference_frame_iau_kore() { - assert_eq!(PyFrame::Kore.name(), "IAU Body-Fixed Frame for Kore"); - assert_eq!(PyFrame::Kore.abbreviation(), "IAU_KORE"); - } - #[test] - fn test_reference_frame_iau_herse() { - assert_eq!(PyFrame::Herse.name(), "IAU Body-Fixed Frame for Herse"); - assert_eq!(PyFrame::Herse.abbreviation(), "IAU_HERSE"); - } - #[test] - fn test_reference_frame_iau_dia() { - assert_eq!(PyFrame::Dia.name(), "IAU Body-Fixed Frame for Dia"); - assert_eq!(PyFrame::Dia.abbreviation(), "IAU_DIA"); - } - #[test] - fn test_reference_frame_iau_mimas() { - assert_eq!(PyFrame::Mimas.name(), "IAU Body-Fixed Frame for Mimas"); - assert_eq!(PyFrame::Mimas.abbreviation(), "IAU_MIMAS"); - } - #[test] - fn test_reference_frame_iau_enceladus() { - assert_eq!( - PyFrame::Enceladus.name(), - "IAU Body-Fixed Frame for Enceladus" - ); - assert_eq!(PyFrame::Enceladus.abbreviation(), "IAU_ENCELADUS"); - } - #[test] - fn test_reference_frame_iau_tethys() { - assert_eq!(PyFrame::Tethys.name(), "IAU Body-Fixed Frame for Tethys"); - assert_eq!(PyFrame::Tethys.abbreviation(), "IAU_TETHYS"); - } - #[test] - fn test_reference_frame_iau_dione() { - assert_eq!(PyFrame::Dione.name(), "IAU Body-Fixed Frame for Dione"); - assert_eq!(PyFrame::Dione.abbreviation(), "IAU_DIONE"); - } - #[test] - fn test_reference_frame_iau_rhea() { - assert_eq!(PyFrame::Rhea.name(), "IAU Body-Fixed Frame for Rhea"); - assert_eq!(PyFrame::Rhea.abbreviation(), "IAU_RHEA"); - } - #[test] - fn test_reference_frame_iau_titan() { - assert_eq!(PyFrame::Titan.name(), "IAU Body-Fixed Frame for Titan"); - assert_eq!(PyFrame::Titan.abbreviation(), "IAU_TITAN"); - } - #[test] - fn test_reference_frame_iau_hyperion() { - assert_eq!( - PyFrame::Hyperion.name(), - "IAU Body-Fixed Frame for Hyperion" - ); - assert_eq!(PyFrame::Hyperion.abbreviation(), "IAU_HYPERION"); - } - #[test] - fn test_reference_frame_iau_iapetus() { - assert_eq!(PyFrame::Iapetus.name(), "IAU Body-Fixed Frame for Iapetus"); - assert_eq!(PyFrame::Iapetus.abbreviation(), "IAU_IAPETUS"); - } - #[test] - fn test_reference_frame_iau_phoebe() { - assert_eq!(PyFrame::Phoebe.name(), "IAU Body-Fixed Frame for Phoebe"); - assert_eq!(PyFrame::Phoebe.abbreviation(), "IAU_PHOEBE"); - } - #[test] - fn test_reference_frame_iau_janus() { - assert_eq!(PyFrame::Janus.name(), "IAU Body-Fixed Frame for Janus"); - assert_eq!(PyFrame::Janus.abbreviation(), "IAU_JANUS"); - } - #[test] - fn test_reference_frame_iau_epimetheus() { - assert_eq!( - PyFrame::Epimetheus.name(), - "IAU Body-Fixed Frame for Epimetheus" - ); - assert_eq!(PyFrame::Epimetheus.abbreviation(), "IAU_EPIMETHEUS"); - } - #[test] - fn test_reference_frame_iau_helene() { - assert_eq!(PyFrame::Helene.name(), "IAU Body-Fixed Frame for Helene"); - assert_eq!(PyFrame::Helene.abbreviation(), "IAU_HELENE"); - } - #[test] - fn test_reference_frame_iau_telesto() { - assert_eq!(PyFrame::Telesto.name(), "IAU Body-Fixed Frame for Telesto"); - assert_eq!(PyFrame::Telesto.abbreviation(), "IAU_TELESTO"); - } - #[test] - fn test_reference_frame_iau_calypso() { - assert_eq!(PyFrame::Calypso.name(), "IAU Body-Fixed Frame for Calypso"); - assert_eq!(PyFrame::Calypso.abbreviation(), "IAU_CALYPSO"); - } - #[test] - fn test_reference_frame_iau_atlas() { - assert_eq!(PyFrame::Atlas.name(), "IAU Body-Fixed Frame for Atlas"); - assert_eq!(PyFrame::Atlas.abbreviation(), "IAU_ATLAS"); - } - #[test] - fn test_reference_frame_iau_prometheus() { - assert_eq!( - PyFrame::Prometheus.name(), - "IAU Body-Fixed Frame for Prometheus" - ); - assert_eq!(PyFrame::Prometheus.abbreviation(), "IAU_PROMETHEUS"); - } - #[test] - fn test_reference_frame_iau_pandora() { - assert_eq!(PyFrame::Pandora.name(), "IAU Body-Fixed Frame for Pandora"); - assert_eq!(PyFrame::Pandora.abbreviation(), "IAU_PANDORA"); - } - #[test] - fn test_reference_frame_iau_pan() { - assert_eq!(PyFrame::Pan.name(), "IAU Body-Fixed Frame for Pan"); - assert_eq!(PyFrame::Pan.abbreviation(), "IAU_PAN"); - } - #[test] - fn test_reference_frame_iau_ymir() { - assert_eq!(PyFrame::Ymir.name(), "IAU Body-Fixed Frame for Ymir"); - assert_eq!(PyFrame::Ymir.abbreviation(), "IAU_YMIR"); - } - #[test] - fn test_reference_frame_iau_paaliaq() { - assert_eq!(PyFrame::Paaliaq.name(), "IAU Body-Fixed Frame for Paaliaq"); - assert_eq!(PyFrame::Paaliaq.abbreviation(), "IAU_PAALIAQ"); - } - #[test] - fn test_reference_frame_iau_tarvos() { - assert_eq!(PyFrame::Tarvos.name(), "IAU Body-Fixed Frame for Tarvos"); - assert_eq!(PyFrame::Tarvos.abbreviation(), "IAU_TARVOS"); - } - #[test] - fn test_reference_frame_iau_ijiraq() { - assert_eq!(PyFrame::Ijiraq.name(), "IAU Body-Fixed Frame for Ijiraq"); - assert_eq!(PyFrame::Ijiraq.abbreviation(), "IAU_IJIRAQ"); - } - #[test] - fn test_reference_frame_iau_suttungr() { - assert_eq!( - PyFrame::Suttungr.name(), - "IAU Body-Fixed Frame for Suttungr" - ); - assert_eq!(PyFrame::Suttungr.abbreviation(), "IAU_SUTTUNGR"); - } - #[test] - fn test_reference_frame_iau_kiviuq() { - assert_eq!(PyFrame::Kiviuq.name(), "IAU Body-Fixed Frame for Kiviuq"); - assert_eq!(PyFrame::Kiviuq.abbreviation(), "IAU_KIVIUQ"); - } - #[test] - fn test_reference_frame_iau_mundilfari() { - assert_eq!( - PyFrame::Mundilfari.name(), - "IAU Body-Fixed Frame for Mundilfari" - ); - assert_eq!(PyFrame::Mundilfari.abbreviation(), "IAU_MUNDILFARI"); - } - #[test] - fn test_reference_frame_iau_albiorix() { - assert_eq!( - PyFrame::Albiorix.name(), - "IAU Body-Fixed Frame for Albiorix" - ); - assert_eq!(PyFrame::Albiorix.abbreviation(), "IAU_ALBIORIX"); - } - #[test] - fn test_reference_frame_iau_skathi() { - assert_eq!(PyFrame::Skathi.name(), "IAU Body-Fixed Frame for Skathi"); - assert_eq!(PyFrame::Skathi.abbreviation(), "IAU_SKATHI"); - } - #[test] - fn test_reference_frame_iau_erriapus() { - assert_eq!( - PyFrame::Erriapus.name(), - "IAU Body-Fixed Frame for Erriapus" - ); - assert_eq!(PyFrame::Erriapus.abbreviation(), "IAU_ERRIAPUS"); - } - #[test] - fn test_reference_frame_iau_siarnaq() { - assert_eq!(PyFrame::Siarnaq.name(), "IAU Body-Fixed Frame for Siarnaq"); - assert_eq!(PyFrame::Siarnaq.abbreviation(), "IAU_SIARNAQ"); - } - #[test] - fn test_reference_frame_iau_thrymr() { - assert_eq!(PyFrame::Thrymr.name(), "IAU Body-Fixed Frame for Thrymr"); - assert_eq!(PyFrame::Thrymr.abbreviation(), "IAU_THRYMR"); - } - #[test] - fn test_reference_frame_iau_narvi() { - assert_eq!(PyFrame::Narvi.name(), "IAU Body-Fixed Frame for Narvi"); - assert_eq!(PyFrame::Narvi.abbreviation(), "IAU_NARVI"); - } - #[test] - fn test_reference_frame_iau_methone() { - assert_eq!(PyFrame::Methone.name(), "IAU Body-Fixed Frame for Methone"); - assert_eq!(PyFrame::Methone.abbreviation(), "IAU_METHONE"); - } - #[test] - fn test_reference_frame_iau_pallene() { - assert_eq!(PyFrame::Pallene.name(), "IAU Body-Fixed Frame for Pallene"); - assert_eq!(PyFrame::Pallene.abbreviation(), "IAU_PALLENE"); - } - #[test] - fn test_reference_frame_iau_polydeuces() { - assert_eq!( - PyFrame::Polydeuces.name(), - "IAU Body-Fixed Frame for Polydeuces" - ); - assert_eq!(PyFrame::Polydeuces.abbreviation(), "IAU_POLYDEUCES"); - } - #[test] - fn test_reference_frame_iau_daphnis() { - assert_eq!(PyFrame::Daphnis.name(), "IAU Body-Fixed Frame for Daphnis"); - assert_eq!(PyFrame::Daphnis.abbreviation(), "IAU_DAPHNIS"); - } - #[test] - fn test_reference_frame_iau_aegir() { - assert_eq!(PyFrame::Aegir.name(), "IAU Body-Fixed Frame for Aegir"); - assert_eq!(PyFrame::Aegir.abbreviation(), "IAU_AEGIR"); - } - #[test] - fn test_reference_frame_iau_bebhionn() { - assert_eq!( - PyFrame::Bebhionn.name(), - "IAU Body-Fixed Frame for Bebhionn" - ); - assert_eq!(PyFrame::Bebhionn.abbreviation(), "IAU_BEBHIONN"); - } - #[test] - fn test_reference_frame_iau_bergelmir() { - assert_eq!( - PyFrame::Bergelmir.name(), - "IAU Body-Fixed Frame for Bergelmir" - ); - assert_eq!(PyFrame::Bergelmir.abbreviation(), "IAU_BERGELMIR"); - } - #[test] - fn test_reference_frame_iau_bestla() { - assert_eq!(PyFrame::Bestla.name(), "IAU Body-Fixed Frame for Bestla"); - assert_eq!(PyFrame::Bestla.abbreviation(), "IAU_BESTLA"); - } - #[test] - fn test_reference_frame_iau_farbauti() { - assert_eq!( - PyFrame::Farbauti.name(), - "IAU Body-Fixed Frame for Farbauti" - ); - assert_eq!(PyFrame::Farbauti.abbreviation(), "IAU_FARBAUTI"); - } - #[test] - fn test_reference_frame_iau_fenrir() { - assert_eq!(PyFrame::Fenrir.name(), "IAU Body-Fixed Frame for Fenrir"); - assert_eq!(PyFrame::Fenrir.abbreviation(), "IAU_FENRIR"); - } - #[test] - fn test_reference_frame_iau_fornjot() { - assert_eq!(PyFrame::Fornjot.name(), "IAU Body-Fixed Frame for Fornjot"); - assert_eq!(PyFrame::Fornjot.abbreviation(), "IAU_FORNJOT"); - } - #[test] - fn test_reference_frame_iau_hati() { - assert_eq!(PyFrame::Hati.name(), "IAU Body-Fixed Frame for Hati"); - assert_eq!(PyFrame::Hati.abbreviation(), "IAU_HATI"); - } - #[test] - fn test_reference_frame_iau_hyrrokkin() { - assert_eq!( - PyFrame::Hyrrokkin.name(), - "IAU Body-Fixed Frame for Hyrrokkin" - ); - assert_eq!(PyFrame::Hyrrokkin.abbreviation(), "IAU_HYRROKKIN"); - } - #[test] - fn test_reference_frame_iau_kari() { - assert_eq!(PyFrame::Kari.name(), "IAU Body-Fixed Frame for Kari"); - assert_eq!(PyFrame::Kari.abbreviation(), "IAU_KARI"); - } - #[test] - fn test_reference_frame_iau_loge() { - assert_eq!(PyFrame::Loge.name(), "IAU Body-Fixed Frame for Loge"); - assert_eq!(PyFrame::Loge.abbreviation(), "IAU_LOGE"); - } - #[test] - fn test_reference_frame_iau_skoll() { - assert_eq!(PyFrame::Skoll.name(), "IAU Body-Fixed Frame for Skoll"); - assert_eq!(PyFrame::Skoll.abbreviation(), "IAU_SKOLL"); - } - #[test] - fn test_reference_frame_iau_surtur() { - assert_eq!(PyFrame::Surtur.name(), "IAU Body-Fixed Frame for Surtur"); - assert_eq!(PyFrame::Surtur.abbreviation(), "IAU_SURTUR"); - } - #[test] - fn test_reference_frame_iau_anthe() { - assert_eq!(PyFrame::Anthe.name(), "IAU Body-Fixed Frame for Anthe"); - assert_eq!(PyFrame::Anthe.abbreviation(), "IAU_ANTHE"); - } - #[test] - fn test_reference_frame_iau_jarnsaxa() { - assert_eq!( - PyFrame::Jarnsaxa.name(), - "IAU Body-Fixed Frame for Jarnsaxa" - ); - assert_eq!(PyFrame::Jarnsaxa.abbreviation(), "IAU_JARNSAXA"); - } - #[test] - fn test_reference_frame_iau_greip() { - assert_eq!(PyFrame::Greip.name(), "IAU Body-Fixed Frame for Greip"); - assert_eq!(PyFrame::Greip.abbreviation(), "IAU_GREIP"); - } - #[test] - fn test_reference_frame_iau_tarqeq() { - assert_eq!(PyFrame::Tarqeq.name(), "IAU Body-Fixed Frame for Tarqeq"); - assert_eq!(PyFrame::Tarqeq.abbreviation(), "IAU_TARQEQ"); - } - #[test] - fn test_reference_frame_iau_aegaeon() { - assert_eq!(PyFrame::Aegaeon.name(), "IAU Body-Fixed Frame for Aegaeon"); - assert_eq!(PyFrame::Aegaeon.abbreviation(), "IAU_AEGAEON"); - } - #[test] - fn test_reference_frame_iau_ariel() { - assert_eq!(PyFrame::Ariel.name(), "IAU Body-Fixed Frame for Ariel"); - assert_eq!(PyFrame::Ariel.abbreviation(), "IAU_ARIEL"); - } - #[test] - fn test_reference_frame_iau_umbriel() { - assert_eq!(PyFrame::Umbriel.name(), "IAU Body-Fixed Frame for Umbriel"); - assert_eq!(PyFrame::Umbriel.abbreviation(), "IAU_UMBRIEL"); - } - #[test] - fn test_reference_frame_iau_titania() { - assert_eq!(PyFrame::Titania.name(), "IAU Body-Fixed Frame for Titania"); - assert_eq!(PyFrame::Titania.abbreviation(), "IAU_TITANIA"); - } - #[test] - fn test_reference_frame_iau_oberon() { - assert_eq!(PyFrame::Oberon.name(), "IAU Body-Fixed Frame for Oberon"); - assert_eq!(PyFrame::Oberon.abbreviation(), "IAU_OBERON"); - } - #[test] - fn test_reference_frame_iau_miranda() { - assert_eq!(PyFrame::Miranda.name(), "IAU Body-Fixed Frame for Miranda"); - assert_eq!(PyFrame::Miranda.abbreviation(), "IAU_MIRANDA"); - } - #[test] - fn test_reference_frame_iau_cordelia() { - assert_eq!( - PyFrame::Cordelia.name(), - "IAU Body-Fixed Frame for Cordelia" - ); - assert_eq!(PyFrame::Cordelia.abbreviation(), "IAU_CORDELIA"); - } - #[test] - fn test_reference_frame_iau_ophelia() { - assert_eq!(PyFrame::Ophelia.name(), "IAU Body-Fixed Frame for Ophelia"); - assert_eq!(PyFrame::Ophelia.abbreviation(), "IAU_OPHELIA"); - } - #[test] - fn test_reference_frame_iau_bianca() { - assert_eq!(PyFrame::Bianca.name(), "IAU Body-Fixed Frame for Bianca"); - assert_eq!(PyFrame::Bianca.abbreviation(), "IAU_BIANCA"); - } - #[test] - fn test_reference_frame_iau_cressida() { - assert_eq!( - PyFrame::Cressida.name(), - "IAU Body-Fixed Frame for Cressida" - ); - assert_eq!(PyFrame::Cressida.abbreviation(), "IAU_CRESSIDA"); - } - #[test] - fn test_reference_frame_iau_desdemona() { - assert_eq!( - PyFrame::Desdemona.name(), - "IAU Body-Fixed Frame for Desdemona" - ); - assert_eq!(PyFrame::Desdemona.abbreviation(), "IAU_DESDEMONA"); - } - #[test] - fn test_reference_frame_iau_juliet() { - assert_eq!(PyFrame::Juliet.name(), "IAU Body-Fixed Frame for Juliet"); - assert_eq!(PyFrame::Juliet.abbreviation(), "IAU_JULIET"); - } - #[test] - fn test_reference_frame_iau_portia() { - assert_eq!(PyFrame::Portia.name(), "IAU Body-Fixed Frame for Portia"); - assert_eq!(PyFrame::Portia.abbreviation(), "IAU_PORTIA"); - } - #[test] - fn test_reference_frame_iau_rosalind() { - assert_eq!( - PyFrame::Rosalind.name(), - "IAU Body-Fixed Frame for Rosalind" - ); - assert_eq!(PyFrame::Rosalind.abbreviation(), "IAU_ROSALIND"); - } - #[test] - fn test_reference_frame_iau_belinda() { - assert_eq!(PyFrame::Belinda.name(), "IAU Body-Fixed Frame for Belinda"); - assert_eq!(PyFrame::Belinda.abbreviation(), "IAU_BELINDA"); - } - #[test] - fn test_reference_frame_iau_puck() { - assert_eq!(PyFrame::Puck.name(), "IAU Body-Fixed Frame for Puck"); - assert_eq!(PyFrame::Puck.abbreviation(), "IAU_PUCK"); - } - #[test] - fn test_reference_frame_iau_caliban() { - assert_eq!(PyFrame::Caliban.name(), "IAU Body-Fixed Frame for Caliban"); - assert_eq!(PyFrame::Caliban.abbreviation(), "IAU_CALIBAN"); - } - #[test] - fn test_reference_frame_iau_sycorax() { - assert_eq!(PyFrame::Sycorax.name(), "IAU Body-Fixed Frame for Sycorax"); - assert_eq!(PyFrame::Sycorax.abbreviation(), "IAU_SYCORAX"); - } - #[test] - fn test_reference_frame_iau_prospero() { - assert_eq!( - PyFrame::Prospero.name(), - "IAU Body-Fixed Frame for Prospero" - ); - assert_eq!(PyFrame::Prospero.abbreviation(), "IAU_PROSPERO"); - } - #[test] - fn test_reference_frame_iau_setebos() { - assert_eq!(PyFrame::Setebos.name(), "IAU Body-Fixed Frame for Setebos"); - assert_eq!(PyFrame::Setebos.abbreviation(), "IAU_SETEBOS"); - } - #[test] - fn test_reference_frame_iau_stephano() { - assert_eq!( - PyFrame::Stephano.name(), - "IAU Body-Fixed Frame for Stephano" - ); - assert_eq!(PyFrame::Stephano.abbreviation(), "IAU_STEPHANO"); - } - #[test] - fn test_reference_frame_iau_trinculo() { - assert_eq!( - PyFrame::Trinculo.name(), - "IAU Body-Fixed Frame for Trinculo" - ); - assert_eq!(PyFrame::Trinculo.abbreviation(), "IAU_TRINCULO"); - } - #[test] - fn test_reference_frame_iau_francisco() { - assert_eq!( - PyFrame::Francisco.name(), - "IAU Body-Fixed Frame for Francisco" - ); - assert_eq!(PyFrame::Francisco.abbreviation(), "IAU_FRANCISCO"); - } - #[test] - fn test_reference_frame_iau_margaret() { - assert_eq!( - PyFrame::Margaret.name(), - "IAU Body-Fixed Frame for Margaret" - ); - assert_eq!(PyFrame::Margaret.abbreviation(), "IAU_MARGARET"); - } - #[test] - fn test_reference_frame_iau_ferdinand() { - assert_eq!( - PyFrame::Ferdinand.name(), - "IAU Body-Fixed Frame for Ferdinand" - ); - assert_eq!(PyFrame::Ferdinand.abbreviation(), "IAU_FERDINAND"); - } - #[test] - fn test_reference_frame_iau_perdita() { - assert_eq!(PyFrame::Perdita.name(), "IAU Body-Fixed Frame for Perdita"); - assert_eq!(PyFrame::Perdita.abbreviation(), "IAU_PERDITA"); - } - #[test] - fn test_reference_frame_iau_mab() { - assert_eq!(PyFrame::Mab.name(), "IAU Body-Fixed Frame for Mab"); - assert_eq!(PyFrame::Mab.abbreviation(), "IAU_MAB"); - } - #[test] - fn test_reference_frame_iau_cupid() { - assert_eq!(PyFrame::Cupid.name(), "IAU Body-Fixed Frame for Cupid"); - assert_eq!(PyFrame::Cupid.abbreviation(), "IAU_CUPID"); - } - #[test] - fn test_reference_frame_iau_triton() { - assert_eq!(PyFrame::Triton.name(), "IAU Body-Fixed Frame for Triton"); - assert_eq!(PyFrame::Triton.abbreviation(), "IAU_TRITON"); - } - #[test] - fn test_reference_frame_iau_nereid() { - assert_eq!(PyFrame::Nereid.name(), "IAU Body-Fixed Frame for Nereid"); - assert_eq!(PyFrame::Nereid.abbreviation(), "IAU_NEREID"); - } - #[test] - fn test_reference_frame_iau_naiad() { - assert_eq!(PyFrame::Naiad.name(), "IAU Body-Fixed Frame for Naiad"); - assert_eq!(PyFrame::Naiad.abbreviation(), "IAU_NAIAD"); - } - #[test] - fn test_reference_frame_iau_thalassa() { - assert_eq!( - PyFrame::Thalassa.name(), - "IAU Body-Fixed Frame for Thalassa" - ); - assert_eq!(PyFrame::Thalassa.abbreviation(), "IAU_THALASSA"); - } - #[test] - fn test_reference_frame_iau_despina() { - assert_eq!(PyFrame::Despina.name(), "IAU Body-Fixed Frame for Despina"); - assert_eq!(PyFrame::Despina.abbreviation(), "IAU_DESPINA"); - } - #[test] - fn test_reference_frame_iau_galatea() { - assert_eq!(PyFrame::Galatea.name(), "IAU Body-Fixed Frame for Galatea"); - assert_eq!(PyFrame::Galatea.abbreviation(), "IAU_GALATEA"); - } - #[test] - fn test_reference_frame_iau_larissa() { - assert_eq!(PyFrame::Larissa.name(), "IAU Body-Fixed Frame for Larissa"); - assert_eq!(PyFrame::Larissa.abbreviation(), "IAU_LARISSA"); - } - #[test] - fn test_reference_frame_iau_proteus() { - assert_eq!(PyFrame::Proteus.name(), "IAU Body-Fixed Frame for Proteus"); - assert_eq!(PyFrame::Proteus.abbreviation(), "IAU_PROTEUS"); - } - #[test] - fn test_reference_frame_iau_halimede() { - assert_eq!( - PyFrame::Halimede.name(), - "IAU Body-Fixed Frame for Halimede" - ); - assert_eq!(PyFrame::Halimede.abbreviation(), "IAU_HALIMEDE"); - } - #[test] - fn test_reference_frame_iau_psamathe() { - assert_eq!( - PyFrame::Psamathe.name(), - "IAU Body-Fixed Frame for Psamathe" - ); - assert_eq!(PyFrame::Psamathe.abbreviation(), "IAU_PSAMATHE"); - } - #[test] - fn test_reference_frame_iau_sao() { - assert_eq!(PyFrame::Sao.name(), "IAU Body-Fixed Frame for Sao"); - assert_eq!(PyFrame::Sao.abbreviation(), "IAU_SAO"); - } - #[test] - fn test_reference_frame_iau_laomedeia() { - assert_eq!( - PyFrame::Laomedeia.name(), - "IAU Body-Fixed Frame for Laomedeia" - ); - assert_eq!(PyFrame::Laomedeia.abbreviation(), "IAU_LAOMEDEIA"); - } - #[test] - fn test_reference_frame_iau_neso() { - assert_eq!(PyFrame::Neso.name(), "IAU Body-Fixed Frame for Neso"); - assert_eq!(PyFrame::Neso.abbreviation(), "IAU_NESO"); - } - #[test] - fn test_reference_frame_iau_charon() { - assert_eq!(PyFrame::Charon.name(), "IAU Body-Fixed Frame for Charon"); - assert_eq!(PyFrame::Charon.abbreviation(), "IAU_CHARON"); - } - #[test] - fn test_reference_frame_iau_nix() { - assert_eq!(PyFrame::Nix.name(), "IAU Body-Fixed Frame for Nix"); - assert_eq!(PyFrame::Nix.abbreviation(), "IAU_NIX"); - } - #[test] - fn test_reference_frame_iau_hydra() { - assert_eq!(PyFrame::Hydra.name(), "IAU Body-Fixed Frame for Hydra"); - assert_eq!(PyFrame::Hydra.abbreviation(), "IAU_HYDRA"); - } - #[test] - fn test_reference_frame_iau_kerberos() { - assert_eq!( - PyFrame::Kerberos.name(), - "IAU Body-Fixed Frame for Kerberos" - ); - assert_eq!(PyFrame::Kerberos.abbreviation(), "IAU_KERBEROS"); - } - #[test] - fn test_reference_frame_iau_styx() { - assert_eq!(PyFrame::Styx.name(), "IAU Body-Fixed Frame for Styx"); - assert_eq!(PyFrame::Styx.abbreviation(), "IAU_STYX"); - } - #[test] - fn test_reference_frame_iau_gaspra() { - assert_eq!(PyFrame::Gaspra.name(), "IAU Body-Fixed Frame for Gaspra"); - assert_eq!(PyFrame::Gaspra.abbreviation(), "IAU_GASPRA"); - } - #[test] - fn test_reference_frame_iau_ida() { - assert_eq!(PyFrame::Ida.name(), "IAU Body-Fixed Frame for Ida"); - assert_eq!(PyFrame::Ida.abbreviation(), "IAU_IDA"); - } - #[test] - fn test_reference_frame_iau_dactyl() { - assert_eq!(PyFrame::Dactyl.name(), "IAU Body-Fixed Frame for Dactyl"); - assert_eq!(PyFrame::Dactyl.abbreviation(), "IAU_DACTYL"); - } - #[test] - fn test_reference_frame_iau_ceres() { - assert_eq!(PyFrame::Ceres.name(), "IAU Body-Fixed Frame for Ceres"); - assert_eq!(PyFrame::Ceres.abbreviation(), "IAU_CERES"); - } - #[test] - fn test_reference_frame_iau_pallas() { - assert_eq!(PyFrame::Pallas.name(), "IAU Body-Fixed Frame for Pallas"); - assert_eq!(PyFrame::Pallas.abbreviation(), "IAU_PALLAS"); - } - #[test] - fn test_reference_frame_iau_vesta() { - assert_eq!(PyFrame::Vesta.name(), "IAU Body-Fixed Frame for Vesta"); - assert_eq!(PyFrame::Vesta.abbreviation(), "IAU_VESTA"); - } - #[test] - fn test_reference_frame_iau_psyche() { - assert_eq!(PyFrame::Psyche.name(), "IAU Body-Fixed Frame for Psyche"); - assert_eq!(PyFrame::Psyche.abbreviation(), "IAU_PSYCHE"); - } - #[test] - fn test_reference_frame_iau_lutetia() { - assert_eq!(PyFrame::Lutetia.name(), "IAU Body-Fixed Frame for Lutetia"); - assert_eq!(PyFrame::Lutetia.abbreviation(), "IAU_LUTETIA"); - } - #[test] - fn test_reference_frame_iau_kleopatra() { - assert_eq!( - PyFrame::Kleopatra.name(), - "IAU Body-Fixed Frame for Kleopatra" - ); - assert_eq!(PyFrame::Kleopatra.abbreviation(), "IAU_KLEOPATRA"); - } - #[test] - fn test_reference_frame_iau_eros() { - assert_eq!(PyFrame::Eros.name(), "IAU Body-Fixed Frame for Eros"); - assert_eq!(PyFrame::Eros.abbreviation(), "IAU_EROS"); - } - #[test] - fn test_reference_frame_iau_davida() { - assert_eq!(PyFrame::Davida.name(), "IAU Body-Fixed Frame for Davida"); - assert_eq!(PyFrame::Davida.abbreviation(), "IAU_DAVIDA"); - } - #[test] - fn test_reference_frame_iau_mathilde() { - assert_eq!( - PyFrame::Mathilde.name(), - "IAU Body-Fixed Frame for Mathilde" - ); - assert_eq!(PyFrame::Mathilde.abbreviation(), "IAU_MATHILDE"); - } - #[test] - fn test_reference_frame_iau_steins() { - assert_eq!(PyFrame::Steins.name(), "IAU Body-Fixed Frame for Steins"); - assert_eq!(PyFrame::Steins.abbreviation(), "IAU_STEINS"); - } - #[test] - fn test_reference_frame_iau_braille() { - assert_eq!(PyFrame::Braille.name(), "IAU Body-Fixed Frame for Braille"); - assert_eq!(PyFrame::Braille.abbreviation(), "IAU_BRAILLE"); - } - #[test] - fn test_reference_frame_iau_wilson_harrington() { - assert_eq!( - PyFrame::WilsonHarrington.name(), - "IAU Body-Fixed Frame for Wilson-Harrington" - ); - assert_eq!( - PyFrame::WilsonHarrington.abbreviation(), - "IAU_WILSON_HARRINGTON" - ); - } - #[test] - fn test_reference_frame_iau_toutatis() { - assert_eq!( - PyFrame::Toutatis.name(), - "IAU Body-Fixed Frame for Toutatis" - ); - assert_eq!(PyFrame::Toutatis.abbreviation(), "IAU_TOUTATIS"); - } - #[test] - fn test_reference_frame_iau_itokawa() { - assert_eq!(PyFrame::Itokawa.name(), "IAU Body-Fixed Frame for Itokawa"); - assert_eq!(PyFrame::Itokawa.abbreviation(), "IAU_ITOKAWA"); - } - #[test] - fn test_reference_frame_iau_bennu() { - assert_eq!(PyFrame::Bennu.name(), "IAU Body-Fixed Frame for Bennu"); - assert_eq!(PyFrame::Bennu.abbreviation(), "IAU_BENNU"); - } -} diff --git a/crates/lox-orbits/src/rotations.rs b/crates/lox-orbits/src/rotations.rs index eb18dc48..d6ff74c5 100644 --- a/crates/lox-orbits/src/rotations.rs +++ b/crates/lox-orbits/src/rotations.rs @@ -14,6 +14,11 @@ pub struct Rotation { } impl Rotation { + pub(crate) const IDENTITY: Self = Self { + m: DMat3::IDENTITY, + dm: DMat3::ZERO, + }; + pub fn new(m: DMat3) -> Self { Self { m, dm: DMat3::ZERO } } @@ -28,6 +33,21 @@ impl Rotation { self } + pub fn position_matrix(&self) -> DMat3 { + self.m + } + + pub fn velocity_matrix(&self) -> DMat3 { + self.dm + } + + pub fn compose(&self, other: &Self) -> Self { + Self { + m: other.m * self.m, + dm: other.dm * self.m + other.m * self.dm, + } + } + pub fn transpose(&self) -> Self { let m = self.m.transpose(); let dm = self.dm.transpose(); diff --git a/crates/lox-orbits/src/states.rs b/crates/lox-orbits/src/states.rs index 141ebe50..78f23302 100644 --- a/crates/lox-orbits/src/states.rs +++ b/crates/lox-orbits/src/states.rs @@ -5,32 +5,27 @@ * 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/. */ -use std::f64::consts::{PI, TAU}; -use std::ops::Sub; - use glam::{DMat3, DVec3}; use itertools::Itertools; - -use lox_bodies::{Body, PointMass, RotationalElements, Spheroid}; +use lox_bodies::{ + DynOrigin, MaybePointMass, MaybeSpheroid, Origin, PointMass, RotationalElements, Spheroid, +}; use lox_ephem::{path_from_ids, Ephemeris}; use lox_math::glam::Azimuth; use lox_math::math::{mod_two_pi, normalize_two_pi}; use lox_math::roots::{BracketError, FindRoot, Secant}; use lox_time::{julian_dates::JulianDate, time_scales::Tdb, transformations::TryToScale, TimeLike}; +use std::f64::consts::{PI, TAU}; +use std::ops::Sub; +use thiserror::Error; use crate::anomalies::{eccentric_to_true, hyperbolic_to_true}; -use crate::elements::{is_circular, is_equatorial, Keplerian, ToKeplerian}; -use crate::ground::GroundLocation; -use crate::{ - frames::{ - BodyFixed, CoordinateSystem, FrameTransformationProvider, Icrf, ReferenceFrame, TryToFrame, - }, - origins::{CoordinateOrigin, Origin}, +use crate::elements::{is_circular, is_equatorial, DynKeplerian, Keplerian, KeplerianElements}; +use crate::frames::{ + BodyFixed, CoordinateSystem, DynFrame, FrameTransformationProvider, Icrf, ReferenceFrame, + TryToFrame, }; - -pub trait ToCartesian { - fn to_cartesian(&self) -> State; -} +use crate::ground::{DynGroundLocation, GroundLocation}; #[derive(Debug, Clone, Copy, PartialEq)] pub struct State { @@ -41,6 +36,8 @@ pub struct State { velocity: DVec3, } +pub type DynState = State; + impl State where T: TimeLike, @@ -57,43 +54,11 @@ where } } - pub fn with_frame(&self, frame: U) -> State + pub fn origin(&self) -> O where - T: Clone, O: Clone, { - State::new( - self.time(), - self.position, - self.velocity, - self.origin(), - frame, - ) - } - - pub fn with_origin(&self, origin: U) -> State - where - T: Clone, - R: Clone, - { - State::new( - self.time(), - self.position, - self.velocity, - origin, - self.reference_frame(), - ) - } - - pub fn with_origin_and_frame( - &self, - origin: U, - frame: V, - ) -> State - where - T: Clone, - { - State::new(self.time(), self.position, self.velocity, origin, frame) + self.origin.clone() } pub fn time(&self) -> T @@ -112,21 +77,74 @@ where } } +fn rotation_lvlh(position: DVec3, velocity: DVec3) -> DMat3 { + let r = position.normalize(); + let v = velocity.normalize(); + let z = -r; + let y = -r.cross(v); + let x = y.cross(z); + DMat3::from_cols(x, y, z) +} + impl State where T: TimeLike, O: Origin, { pub fn rotation_lvlh(&self) -> DMat3 { - let r = self.position().normalize(); - let v = self.velocity().normalize(); - let z = -r; - let y = -r.cross(v); - let x = y.cross(z); - DMat3::from_cols(x, y, z) + rotation_lvlh(self.position(), self.velocity()) } } +impl DynState +where + T: TimeLike, +{ + pub fn try_rotation_lvlh(&self) -> Result { + if self.frame != DynFrame::Icrf { + // TODO: better error type + return Err("only valid for ICRF"); + } + Ok(rotation_lvlh(self.position(), self.velocity())) + } +} + +type LonLatAlt = (f64, f64, f64); + +fn rv_to_lla(r: DVec3, r_eq: f64, f: f64) -> Result { + let rm = r.length(); + let r_delta = (r.x.powi(2) + r.y.powi(2)).sqrt(); + let mut lon = r.y.atan2(r.x); + + if lon.abs() >= PI { + if lon < 0.0 { + lon += TAU; + } else { + lon -= TAU; + } + } + + let delta = (r.z / rm).asin(); + + let root_finder = Secant::default(); + + let lat = root_finder.find( + |lat| { + let e = (2.0 * f - f.powi(2)).sqrt(); + let c = r_eq / (1.0 - e.powi(2) * lat.sin().powi(2)).sqrt(); + (r.z + c * e.powi(2) * lat.sin()) / r_delta - lat.tan() + }, + delta, + )?; + + let e = (2.0 * f - f.powi(2)).sqrt(); + let c = r_eq / (1.0 - e.powi(2) * lat.sin().powi(2)).sqrt(); + + let alt = r_delta / lat.cos() - c; + + Ok((lon, lat, alt)) +} + impl State> where T: TimeLike, @@ -134,39 +152,43 @@ where { pub fn to_ground_location(&self) -> Result, BracketError> { let r = self.position(); - let rm = r.length(); - let r_delta = (r.x.powi(2) + r.y.powi(2)).sqrt(); - let mut lon = r.y.atan2(r.x); - - if lon.abs() >= PI { - if lon < 0.0 { - lon += TAU; - } else { - lon -= TAU; - } - } - - let delta = (r.z / rm).asin(); - - let root_finder = Secant::default(); let r_eq = self.origin.equatorial_radius(); let f = self.origin.flattening(); + let (lon, lat, alt) = rv_to_lla(r, r_eq, f)?; + + Ok(GroundLocation::new(lon, lat, alt, self.origin())) + } +} - let lat = root_finder.find( - |lat| { - let e = (2.0 * f - f.powi(2)).sqrt(); - let c = r_eq / (1.0 - e.powi(2) * lat.sin().powi(2)).sqrt(); - (r.z + c * e.powi(2) * lat.sin()) / r_delta - lat.tan() - }, - delta, - )?; +#[derive(Debug, Clone, Error, Eq, PartialEq)] +pub enum StateToDynGroundError { + #[error("equatorial radius and flattening factor are not available for origin `{}`", .0.name())] + UndefinedSpheroid(DynOrigin), + #[error(transparent)] + BracketError(#[from] BracketError), + #[error("not a body-fixed frame {0}")] + NonBodyFixedFrame(String), +} - let e = (2.0 * f - f.powi(2)).sqrt(); - let c = r_eq / (1.0 - e.powi(2) * lat.sin().powi(2)).sqrt(); +impl DynState { + pub fn to_dyn_ground_location(&self) -> Result { + if !self.frame.is_rotating() { + return Err(StateToDynGroundError::NonBodyFixedFrame( + self.frame.name().to_string(), + )); + } + let r = self.position(); + // TODO: Check/transform frame + let (Some(r_eq), Some(f)) = ( + self.origin.maybe_equatorial_radius(), + self.origin.maybe_flattening(), + ) else { + return Err(StateToDynGroundError::UndefinedSpheroid(self.origin)); + }; - let alt = r_delta / lat.cos() - c; + let (lon, lat, alt) = rv_to_lla(r, r_eq, f)?; - Ok(GroundLocation::new(lon, lat, alt, self.origin())) + Ok(DynGroundLocation::with_dynamic(lon, lat, alt, self.origin).unwrap()) } } @@ -185,23 +207,12 @@ where } } -impl State -where - T: TimeLike, - O: PointMass, - R: ReferenceFrame, -{ - fn eccentricity_vector(&self) -> DVec3 { - let r = self.position(); - let v = self.velocity(); - let mu = self.origin.gravitational_parameter(); +fn eccentricity_vector(r: DVec3, v: DVec3, mu: f64) -> DVec3 { + let rm = r.length(); + let v2 = v.dot(v); + let rv = r.dot(v); - let rm = r.length(); - let v2 = v.dot(v); - let rv = r.dot(v); - - ((v2 - mu / rm) * r - rv * v) / mu - } + ((v2 - mu / rm) * r - rv * v) / mu } impl CoordinateSystem for State @@ -215,27 +226,47 @@ where } } -impl CoordinateOrigin for State +impl State where - T: TimeLike, + T: TimeLike + Clone, O: Origin + Clone, - R: ReferenceFrame, { - fn origin(&self) -> O { - self.origin.clone() + pub fn to_origin( + &self, + target: O1, + ephemeris: &E, + ) -> Result, E::Error> { + // TODO: Fix time scale + let epoch = self.time().seconds_since_j2000(); + let mut pos = self.position(); + let mut vel = self.velocity(); + let mut pos_eph = DVec3::ZERO; + let mut vel_eph = DVec3::ZERO; + let origin_id = self.origin.id(); + let target_id = target.id(); + let path = path_from_ids(origin_id.0, target_id.0); + for (origin, target) in path.into_iter().tuple_windows() { + let (p, v) = ephemeris.state(epoch, origin, target)?; + let p: DVec3 = p.into(); + let v: DVec3 = v.into(); + pos_eph += p; + vel_eph += v; + } + pos -= pos_eph; + vel -= vel_eph; + Ok(State::new(self.time(), pos, vel, target, Icrf)) } } -impl State +impl DynState where T: TimeLike + Clone, - O: Origin + Body + Clone, { - pub fn to_origin( + pub fn to_origin_dynamic( &self, target: O1, ephemeris: &E, - ) -> Result, E::Error> { + ) -> Result, E::Error> { // TODO: Fix time scale let epoch = self.time().seconds_since_j2000(); let mut pos = self.position(); @@ -254,7 +285,7 @@ where } pos -= pos_eph; vel -= vel_eph; - Ok(State::new(self.time(), pos, vel, target, Icrf)) + Ok(State::new(self.time(), pos, vel, target, DynFrame::Icrf)) } } @@ -300,75 +331,113 @@ where } } -impl ToKeplerian for State +pub(crate) fn rv_to_keplerian(r: DVec3, v: DVec3, mu: f64) -> KeplerianElements { + let rm = r.length(); + let vm = v.length(); + let h = r.cross(v); + let hm = h.length(); + let node = DVec3::Z.cross(h); + let e = eccentricity_vector(r, v, mu); + let eccentricity = e.length(); + let inclination = h.angle_between(DVec3::Z); + + let equatorial = is_equatorial(inclination); + let circular = is_circular(eccentricity); + + let semi_major_axis = if circular { + hm.powi(2) / mu + } else { + -mu / (2.0 * (vm.powi(2) / 2.0 - mu / rm)) + }; + + let longitude_of_ascending_node; + let argument_of_periapsis; + let true_anomaly; + if equatorial && !circular { + longitude_of_ascending_node = 0.0; + argument_of_periapsis = e.azimuth(); + true_anomaly = (h.dot(e.cross(r)) / hm).atan2(r.dot(e)); + } else if !equatorial && circular { + longitude_of_ascending_node = node.azimuth(); + argument_of_periapsis = 0.0; + true_anomaly = (r.dot(h.cross(node)) / hm).atan2(r.dot(node)); + } else if equatorial && circular { + longitude_of_ascending_node = 0.0; + argument_of_periapsis = 0.0; + true_anomaly = r.azimuth(); + } else { + if semi_major_axis > 0.0 { + let e_se = r.dot(v) / (mu * semi_major_axis).sqrt(); + let e_ce = (rm * vm.powi(2)) / mu - 1.0; + true_anomaly = eccentric_to_true(e_se.atan2(e_ce), eccentricity); + } else { + let e_sh = r.dot(v) / (-mu * semi_major_axis).sqrt(); + let e_ch = (rm * vm.powi(2)) / mu - 1.0; + true_anomaly = + hyperbolic_to_true(((e_ch + e_sh) / (e_ch - e_sh)).ln() / 2.0, eccentricity); + } + longitude_of_ascending_node = node.azimuth(); + let px = r.dot(node); + let py = r.dot(h.cross(node)) / hm; + argument_of_periapsis = py.atan2(px) - true_anomaly; + } + + KeplerianElements { + semi_major_axis, + eccentricity, + inclination, + longitude_of_ascending_node: mod_two_pi(longitude_of_ascending_node), + argument_of_periapsis: mod_two_pi(argument_of_periapsis), + true_anomaly: normalize_two_pi(true_anomaly, 0.0), + } +} + +impl State where T: TimeLike + Clone, O: PointMass + Clone, - R: ReferenceFrame, { - fn to_keplerian(&self) -> Keplerian { - let mu = self.origin.gravitational_parameter(); + pub fn to_keplerian(&self) -> Keplerian { let r = self.position(); let v = self.velocity(); - let rm = r.length(); - let vm = v.length(); - let h = r.cross(v); - let hm = h.length(); - let node = DVec3::Z.cross(h); - let e = self.eccentricity_vector(); - let eccentricity = e.length(); - let inclination = h.angle_between(DVec3::Z); - - let equatorial = is_equatorial(inclination); - let circular = is_circular(eccentricity); - - let semi_major_axis = if circular { - hm.powi(2) / mu - } else { - -mu / (2.0 * (vm.powi(2) / 2.0 - mu / rm)) + let mu = self.origin.gravitational_parameter(); + let elements = rv_to_keplerian(r, v, mu); + + Keplerian::new( + self.time(), + self.origin(), + elements.semi_major_axis, + elements.eccentricity, + elements.inclination, + elements.longitude_of_ascending_node, + elements.argument_of_periapsis, + elements.true_anomaly, + ) + } +} + +impl DynState +where + T: TimeLike + Clone, +{ + pub fn try_to_keplerian(&self) -> Result, &'static str> { + let Some(mu) = self.origin.maybe_gravitational_parameter() else { + return Err("no gravitational parameter"); }; - let longitude_of_ascending_node; - let argument_of_periapsis; - let true_anomaly; - if equatorial && !circular { - longitude_of_ascending_node = 0.0; - argument_of_periapsis = e.azimuth(); - true_anomaly = (h.dot(e.cross(r)) / hm).atan2(r.dot(e)); - } else if !equatorial && circular { - longitude_of_ascending_node = node.azimuth(); - argument_of_periapsis = 0.0; - true_anomaly = (r.dot(h.cross(node)) / hm).atan2(r.dot(node)); - } else if equatorial && circular { - longitude_of_ascending_node = 0.0; - argument_of_periapsis = 0.0; - true_anomaly = r.azimuth(); - } else { - if semi_major_axis > 0.0 { - let e_se = r.dot(v) / (mu * semi_major_axis).sqrt(); - let e_ce = (rm * vm.powi(2)) / mu - 1.0; - true_anomaly = eccentric_to_true(e_se.atan2(e_ce), eccentricity); - } else { - let e_sh = r.dot(v) / (-mu * semi_major_axis).sqrt(); - let e_ch = (rm * vm.powi(2)) / mu - 1.0; - true_anomaly = - hyperbolic_to_true(((e_ch + e_sh) / (e_ch - e_sh)).ln() / 2.0, eccentricity); - } - longitude_of_ascending_node = node.azimuth(); - let px = r.dot(node); - let py = r.dot(h.cross(node)) / hm; - argument_of_periapsis = py.atan2(px) - true_anomaly; - } + let r = self.position(); + let v = self.velocity(); + let elements = rv_to_keplerian(r, v, mu); - Keplerian::new( + Keplerian::with_dynamic( self.time(), self.origin(), - semi_major_axis, - eccentricity, - inclination, - mod_two_pi(longitude_of_ascending_node), - mod_two_pi(argument_of_periapsis), - normalize_two_pi(true_anomaly, 0.0), + elements.semi_major_axis, + elements.eccentricity, + elements.inclination, + elements.longitude_of_ascending_node, + elements.argument_of_periapsis, + elements.true_anomaly, ) } } diff --git a/crates/lox-orbits/src/trajectories.rs b/crates/lox-orbits/src/trajectories.rs index 2604be71..f341aaf0 100644 --- a/crates/lox-orbits/src/trajectories.rs +++ b/crates/lox-orbits/src/trajectories.rs @@ -6,7 +6,7 @@ use glam::DVec3; use lox_ephem::Ephemeris; use thiserror::Error; -use lox_bodies::{Body, RotationalElements}; +use lox_bodies::{DynOrigin, Origin, RotationalElements}; use lox_math::roots::Brent; use lox_math::series::{Series, SeriesError}; use lox_time::time_scales::{Tai, Tdb}; @@ -16,10 +16,9 @@ use lox_time::utc::Utc; use lox_time::{deltas::TimeDelta, Time, TimeLike}; use crate::events::{find_events, find_windows, Event, Window}; -use crate::frames::{BodyFixed, FrameTransformationProvider, Icrf, TryToFrame}; +use crate::frames::{BodyFixed, DynFrame, FrameTransformationProvider, Icrf, TryToFrame}; use crate::{ frames::{CoordinateSystem, ReferenceFrame}, - origins::{CoordinateOrigin, Origin}, states::State, }; @@ -61,6 +60,8 @@ pub struct Trajectory { vz: Series>, } +pub type DynTrajectory = Trajectory; + impl Trajectory where T: TimeLike + Clone, @@ -101,35 +102,8 @@ where }) } - pub fn with_frame(self, frame: R1) -> Trajectory { - let states: Vec> = self - .states - .into_iter() - .map(|s| s.with_frame(frame.clone())) - .collect(); - Trajectory::new(&states).unwrap() - } - - pub fn with_origin(&self, origin: O1) -> Trajectory { - let states: Vec> = self - .states - .iter() - .map(|s| s.with_origin(origin.clone())) - .collect(); - Trajectory::new(&states).unwrap() - } - - pub fn with_origin_and_frame( - &self, - origin: O1, - frame: R1, - ) -> Trajectory { - let states: Vec> = self - .states - .iter() - .map(|s| s.with_origin_and_frame(origin.clone(), frame.clone())) - .collect(); - Trajectory::new(&states).unwrap() + pub fn origin(&self) -> O { + self.states.first().unwrap().origin() } pub fn start_time(&self) -> T { @@ -236,9 +210,9 @@ where impl Trajectory where T: TimeLike + Clone, - O: Origin + Body + Clone, + O: Origin + Origin + Clone, { - pub fn to_origin( + pub fn to_origin( &self, target: O1, ephemeris: &E, @@ -328,17 +302,6 @@ where } } -impl CoordinateOrigin for Trajectory -where - T: TimeLike, - O: Origin + Clone, - R: ReferenceFrame, -{ - fn origin(&self) -> O { - self.states[0].origin() - } -} - impl CoordinateSystem for Trajectory where T: TimeLike, @@ -361,7 +324,7 @@ pub enum TrajectoryTransformationError { impl TryToFrame, P> for Trajectory where T: TryToScale + TimeLike + Clone, - O: Body + Clone, + O: Origin + Clone, R: RotationalElements + Clone, P: FrameTransformationProvider, { diff --git a/crates/lox-space/benches/iau_frames.rs b/crates/lox-space/benches/iau_frames.rs index 86b3675e..f7c6fb39 100644 --- a/crates/lox-space/benches/iau_frames.rs +++ b/crates/lox-space/benches/iau_frames.rs @@ -21,7 +21,7 @@ fn right_ascension() { #[divan::bench] fn right_ascension_dot() { - Jupiter.right_ascension_dot(divan::black_box(0.0)); + Jupiter.right_ascension_rate(divan::black_box(0.0)); } #[divan::bench] @@ -31,17 +31,17 @@ fn declination() { #[divan::bench] fn declination_dot() { - Jupiter.declination_dot(divan::black_box(0.0)); + Jupiter.declination_rate(divan::black_box(0.0)); } #[divan::bench] fn prime_meridian() { - Jupiter.prime_meridian(divan::black_box(0.0)); + Jupiter.rotation_angle(divan::black_box(0.0)); } #[divan::bench] fn prime_meridian_dot() { - Jupiter.prime_meridian_dot(divan::black_box(0.0)); + Jupiter.rotation_rate(divan::black_box(0.0)); } #[divan::bench] diff --git a/crates/lox-space/benches/observables.rs b/crates/lox-space/benches/observables.rs index 8677220d..22a3623a 100644 --- a/crates/lox-space/benches/observables.rs +++ b/crates/lox-space/benches/observables.rs @@ -7,7 +7,7 @@ */ use lox_bodies::Earth; -use lox_orbits::analysis::{elevation, elevation2}; +use lox_orbits::analysis::elevation; use lox_orbits::frames::{Icrf, NoOpFrameTransformationProvider, Topocentric}; use lox_orbits::ground::GroundLocation; use lox_orbits::trajectories::Trajectory; @@ -19,22 +19,6 @@ fn main() { divan::main(); } -#[divan::bench] -fn elevation_interpolation(bencher: divan::Bencher) { - bencher - .with_inputs(|| { - ( - time!(Tai, 2022, 2, 1).unwrap(), - ground_station_trajectory(), - spacecraft_trajectory(), - frame(), - ) - }) - .bench_values(|(t, gs, sc, frame)| { - elevation(t, &frame, &gs, &sc, &NoOpFrameTransformationProvider) - }); -} - #[divan::bench] fn elevation_rotation(bencher: divan::Bencher) { bencher @@ -45,7 +29,7 @@ fn elevation_rotation(bencher: divan::Bencher) { spacecraft_trajectory(), ) }) - .bench_values(|(t, gs, sc)| elevation2(t, &gs, &sc, &NoOpFrameTransformationProvider)); + .bench_values(|(t, gs, sc)| elevation(t, &gs, &sc, &NoOpFrameTransformationProvider)); } fn ground_station_trajectory() -> Trajectory, Earth, Icrf> { @@ -65,9 +49,3 @@ fn spacecraft_trajectory() -> Trajectory, Earth, Icrf> { ) .unwrap() } - -fn frame() -> Topocentric { - let longitude = -4.3676f64.to_radians(); - let latitude = 40.4527f64.to_radians(); - Topocentric::from_coords(longitude, latitude, 0.0, Earth) -} diff --git a/crates/lox-space/examples/iss.rs b/crates/lox-space/examples/iss.rs index 7cc3eedb..12133fdb 100644 --- a/crates/lox-space/examples/iss.rs +++ b/crates/lox-space/examples/iss.rs @@ -7,7 +7,6 @@ */ use lox_bodies::Earth; -use lox_orbits::elements::ToKeplerian; use lox_orbits::frames::Icrf; use lox_orbits::states::State; use lox_orbits::DVec3; diff --git a/crates/lox-space/lox_space.pyi b/crates/lox-space/lox_space.pyi index 6bddccc6..2d27dd53 100644 --- a/crates/lox-space/lox_space.pyi +++ b/crates/lox-space/lox_space.pyi @@ -24,6 +24,11 @@ def visibility( provider: UT1Provider, ): ... +class Origin: + def __new__(cls, origin: str | int): ... + def id(self) -> int: ... + def name(self) -> str: ... + class Frame: def __new__(cls, abbreviation: str): ... def name(self) -> str: ... @@ -115,7 +120,7 @@ class Vallado: class GroundLocation: def __new__( cls, - planet: Planet, + origin: Origin, longitude: float, latitude: float, altitude: float, @@ -287,49 +292,3 @@ class UTC: class UT1Provider: def __new__(cls, path: str): ... - -type Origin = Sun | Barycenter | Planet | Satellite | MinorBody - -class Sun: - def __new__(cls): ... - def id(self) -> int: ... - def name(self) -> str: ... - def gravitational_parameter(self) -> float: ... - def mean_radius(self) -> float: ... - def polar_radius(self) -> float: ... - def equatorial_radius(self) -> float: ... - -class Barycenter: - def __new__(cls, name: str): ... - def id(self) -> int: ... - def name(self) -> str: ... - def gravitational_parameter(self) -> float: ... - -class Planet: - def __new__(cls, name: str): ... - def id(self) -> int: ... - def name(self) -> str: ... - def gravitational_parameter(self) -> float: ... - def mean_radius(self) -> float: ... - def polar_radius(self) -> float: ... - def equatorial_radius(self) -> float: ... - -class Satellite: - def __new__(cls, name: str): ... - def id(self) -> int: ... - def name(self) -> str: ... - def gravitational_parameter(self) -> float: ... - def mean_radius(self) -> float: ... - def polar_radius(self) -> float: ... - def subplanetary_radius(self) -> float: ... - def along_orbit_radius(self) -> float: ... - -class MinorBody: - def __new__(cls, name: str): ... - def id(self) -> int: ... - def name(self) -> str: ... - def gravitational_parameter(self) -> float: ... - def mean_radius(self) -> float: ... - def polar_radius(self) -> float: ... - def subplanetary_radius(self) -> float: ... - def along_orbit_radius(self) -> float: ... diff --git a/crates/lox-space/pyproject.toml b/crates/lox-space/pyproject.toml index b78eb263..30e5d1b1 100644 --- a/crates/lox-space/pyproject.toml +++ b/crates/lox-space/pyproject.toml @@ -7,7 +7,7 @@ classifiers = [ "Programming Language :: Python :: Implementation :: PyPy", ] dependencies = [ - "numpy < 2" + "numpy >= 1.16.0" ] dynamic = ["version"] diff --git a/crates/lox-space/src/lib.rs b/crates/lox-space/src/lib.rs index c56fbddc..0ef95c54 100644 --- a/crates/lox-space/src/lib.rs +++ b/crates/lox-space/src/lib.rs @@ -6,12 +6,12 @@ * file, you can obtain one at https://mozilla.org/MPL/2.0/. */ -use lox_bodies::python::{PyBarycenter, PyMinorBody, PyPlanet, PySatellite, PySun}; +use lox_bodies::python::PyOrigin; use lox_ephem::python::PySpk; use lox_orbits::python::{ - elevation, find_events, find_windows, visibility, PyElevationMask, PyEvent, PyFrame, - PyGroundLocation, PyGroundPropagator, PyKeplerian, PyObservables, PySgp4, PyState, - PyTopocentric, PyTrajectory, PyVallado, PyWindow, + find_events, find_windows, visibility, PyElevationMask, PyEvent, PyFrame, PyGroundLocation, + PyGroundPropagator, PyKeplerian, PyObservables, PySgp4, PyState, PyTrajectory, PyVallado, + PyWindow, }; use pyo3::prelude::*; @@ -26,12 +26,7 @@ fn lox_space(m: &Bound<'_, PyModule>) -> PyResult<()> { m.add_function(wrap_pyfunction!(find_events, m)?)?; m.add_function(wrap_pyfunction!(find_windows, m)?)?; m.add_function(wrap_pyfunction!(visibility, m)?)?; - m.add_function(wrap_pyfunction!(elevation, m)?)?; - m.add_class::()?; - m.add_class::()?; - m.add_class::()?; - m.add_class::()?; - m.add_class::()?; + m.add_class::()?; m.add_class::()?; m.add_class::()?; m.add_class::()?; @@ -46,7 +41,6 @@ fn lox_space(m: &Bound<'_, PyModule>) -> PyResult<()> { m.add_class::()?; m.add_class::()?; m.add_class::()?; - m.add_class::()?; m.add_class::()?; m.add_class::()?; m.add_class::()?; diff --git a/crates/lox-space/tests/conftest.py b/crates/lox-space/tests/conftest.py index b5c56521..cb6c2e39 100644 --- a/crates/lox-space/tests/conftest.py +++ b/crates/lox-space/tests/conftest.py @@ -48,7 +48,7 @@ def estrack(): ] return { name: lox.GroundLocation( - lox.Planet("Earth"), np.radians(lon), np.radians(lat), 0 + lox.Origin("Earth"), np.radians(lon), np.radians(lat), 0 ) for name, lat, lon in stations } diff --git a/crates/lox-space/tests/test_pickle.py b/crates/lox-space/tests/test_pickle.py index b90f33e6..34afb07d 100644 --- a/crates/lox-space/tests/test_pickle.py +++ b/crates/lox-space/tests/test_pickle.py @@ -10,14 +10,17 @@ import pytest -@pytest.mark.parametrize("obj", [ - lox.Sun(), - lox.Barycenter("Solar System Barycenter"), - lox.Planet("Earth"), - lox.Satellite("Moon"), - lox.MinorBody("Ceres"), - lox.ElevationMask.fixed(0.0), -]) +@pytest.mark.parametrize( + "obj", + [ + # lox.Sun(), + # lox.Barycenter("Solar System Barycenter"), + # lox.Planet("Earth"), + # lox.Satellite("Moon"), + # lox.MinorBody("Ceres"), + lox.ElevationMask.fixed(0.0), + ], +) def test_pickle(obj): pickled = pickle.dumps(obj) unpickled = pickle.loads(pickled) diff --git a/crates/lox-space/tests/test_propagators.py b/crates/lox-space/tests/test_propagators.py index dd2a95c6..6c912f23 100644 --- a/crates/lox-space/tests/test_propagators.py +++ b/crates/lox-space/tests/test_propagators.py @@ -20,15 +20,17 @@ def test_sgp4(): t1 = sgp4.time() + lox.TimeDelta.from_minutes(92.821) s1 = sgp4.propagate(t1) k1 = s1.to_keplerian() - assert k1.orbital_period().to_decimal_seconds() == pytest.approx(92.821 * 60, rel=1e-4) + assert k1.orbital_period().to_decimal_seconds() == pytest.approx( + 92.821 * 60, rel=1e-4 + ) def test_ground(provider): lat = np.radians(40.4527) lon = np.radians(-4.3676) tai = lox.UTC.from_iso("2022-01-31T23:00:00").to_tai() - loc = lox.GroundLocation(lox.Planet("Earth"), lon, lat, 0.0) + loc = lox.GroundLocation(lox.Origin("Earth"), lon, lat, 0.0) ground = lox.GroundPropagator(loc, provider) - expected = np.array([-1765.9535510583582, 4524.585984442561, 4120.189198495323]) + expected = np.array([-1760.0326388434466, 4509.415893243589, 4106.374974141291]) actual = ground.propagate(tai).position() npt.assert_allclose(actual, expected, rtol=1e-4) diff --git a/crates/lox-space/tests/test_states.py b/crates/lox-space/tests/test_states.py index 441f3b15..620a106a 100644 --- a/crates/lox-space/tests/test_states.py +++ b/crates/lox-space/tests/test_states.py @@ -20,14 +20,24 @@ def ephemeris(): def test_state_to_ground_location(): - time = lox.Time.from_iso("2024-07-05T09:09:18.173 TAI") + time = lox.UTC.from_iso("2024-07-05T09:09:18.173").to_tai() position = (-5530.01774359, -3487.0895338, -1850.03476185) velocity = (1.29534407, -5.02456882, 5.6391936) - state = lox.State(time, position, velocity, lox.Planet("Earth"), lox.Frame("ICRF")) + state = lox.State( + time, position, velocity, lox.Origin("Earth"), lox.Frame("ICRF") + ).to_frame(lox.Frame("IAU_EARTH")) + npt.assert_allclose( + state.position(), + np.array([-5740.259426667957, 3121.1360727954725, -1863.1826563318027]), + ) + npt.assert_allclose( + state.velocity(), + np.array([-3.53237875783652, -3.152377656863808, 5.642296713889555]), + ) ground = state.to_ground_location() - assert ground.longitude() == pytest.approx(2.646276127963636) - assert ground.latitude() == pytest.approx(-0.2794495715104036) - assert ground.altitude() == pytest.approx(417.8524158044338) + assert ground.longitude() == pytest.approx(2.643578045424445, rel=1e-4) + assert ground.latitude() == pytest.approx(-0.2794439537542346, abs=1e-4) + assert ground.altitude() == pytest.approx(439.2316688043311, rel=1e-4) def test_state_to_origin(ephemeris): @@ -49,7 +59,7 @@ def test_state_to_origin(ephemeris): tai = utc.to_tai() s_earth = lox.State(tai, tuple(r), tuple(v)) - s_venus = s_earth.to_origin(lox.Planet("Venus"), ephemeris) + s_venus = s_earth.to_origin(lox.Origin("Venus"), ephemeris) r_act = s_venus.position() v_act = s_venus.velocity() diff --git a/crates/lox-time/src/lib.rs b/crates/lox-time/src/lib.rs index b0eb82bd..7b000d4c 100644 --- a/crates/lox-time/src/lib.rs +++ b/crates/lox-time/src/lib.rs @@ -77,9 +77,9 @@ pub mod utc; #[derive(Clone, Debug, Error)] #[error( - "Julian date must be between {} and {} seconds since J2000 but was {0}", - i64::MIN, - i64::MAX + "Julian date must be between {min} and {max} seconds since J2000 but was {0}", + min = i64::MIN, + max = i64::MAX )] pub struct JulianDateOutOfRange(f64); diff --git a/crates/lox-time/src/python/deltas.rs b/crates/lox-time/src/python/deltas.rs index 3ffe3cd8..bf0f4cbe 100644 --- a/crates/lox-time/src/python/deltas.rs +++ b/crates/lox-time/src/python/deltas.rs @@ -147,7 +147,7 @@ mod tests { #[test] fn test_pytimedelta_constructors() { Python::with_gil(|py| { - let cls = PyType::new_bound::(py); + let cls = PyType::new::(py); let td = PyTimeDelta::from_seconds(&cls, 123); assert_eq!(td.to_decimal_seconds(), 123.0); let td = PyTimeDelta::from_minutes(&cls, 2.0).unwrap(); diff --git a/crates/lox-time/src/python/time.rs b/crates/lox-time/src/python/time.rs index 164ca5b8..d40c725e 100644 --- a/crates/lox-time/src/python/time.rs +++ b/crates/lox-time/src/python/time.rs @@ -586,7 +586,7 @@ mod tests { fn test_pytime_ops_invalid_rhs() { Python::with_gil(|py| { let t1 = PyTime::new("TAI", 2000, 1, 1, 0, 0, 1.0).unwrap(); - let invalid = PyDict::new_bound(py); + let invalid = PyDict::new(py); t1.__sub__(py, &invalid).unwrap(); }); } @@ -626,7 +626,7 @@ mod tests { #[test] fn test_pytime_from_iso() { Python::with_gil(|py| { - let cls = PyType::new_bound::(py); + let cls = PyType::new::(py); let expected = PyTime::new("TAI", 2000, 1, 1, 0, 0, 0.0).unwrap(); let actual = PyTime::from_iso(&cls, "2000-01-01T00:00:00 TAI", None).unwrap(); assert_eq!(actual, expected); @@ -641,7 +641,7 @@ mod tests { #[should_panic(expected = "invalid ISO")] fn test_pytime_from_iso_invalid() { Python::with_gil(|py| { - let cls = PyType::new_bound::(py); + let cls = PyType::new::(py); let _ = PyTime::from_iso(&cls, "2000-01-01X00:00:00 TAI", None).unwrap(); }) } @@ -650,7 +650,7 @@ mod tests { #[should_panic(expected = "invalid time scale")] fn test_pytime_from_iso_invalid_scale() { Python::with_gil(|py| { - let cls = PyType::new_bound::(py); + let cls = PyType::new::(py); let _ = PyTime::from_iso(&cls, "2000-01-01T00:00:00 UTC", None).unwrap(); }) } @@ -659,7 +659,7 @@ mod tests { #[should_panic(expected = "invalid time scale")] fn test_pytime_from_iso_invalid_scale_arg() { Python::with_gil(|py| { - let cls = PyType::new_bound::(py); + let cls = PyType::new::(py); let _ = PyTime::from_iso(&cls, "2000-01-01T00:00:00 TAI", Some("UTC")).unwrap(); }) } @@ -667,7 +667,7 @@ mod tests { #[test] fn test_pytime_julian_date() { Python::with_gil(|py| { - let cls = PyType::new_bound::(py); + let cls = PyType::new::(py); let time = PyTime::from_julian_date(&cls, "TAI", 0.0, "j2000").unwrap(); assert_eq!(time.julian_date("j2000", "seconds").unwrap(), 0.0); assert_eq!(time.julian_date("j2000", "days").unwrap(), 0.0); @@ -701,7 +701,7 @@ mod tests { #[test] fn test_pytime_from_two_part_julian_date() { Python::with_gil(|py| { - let cls = PyType::new_bound::(py); + let cls = PyType::new::(py); let expected = PyTime::new("TAI", 2024, 7, 11, 8, 2, 14.0).unwrap(); let (jd1, jd2) = expected.two_part_julian_date(); let actual = PyTime::from_two_part_julian_date(&cls, "TAI", jd1, jd2).unwrap(); @@ -712,7 +712,7 @@ mod tests { #[test] fn test_pytime_from_day_of_year() { Python::with_gil(|py| { - let cls = PyType::new_bound::(py); + let cls = PyType::new::(py); let expected = PyTime::new("TAI", 2024, 12, 31, 0, 0, 0.0).unwrap(); let actual = PyTime::from_day_of_year(&cls, "TAI", 2024, 366, 0, 0, 0.0).unwrap(); assert_eq!(actual, expected); diff --git a/crates/lox-time/src/python/utc.rs b/crates/lox-time/src/python/utc.rs index 2a59615c..f1873f12 100644 --- a/crates/lox-time/src/python/utc.rs +++ b/crates/lox-time/src/python/utc.rs @@ -180,7 +180,7 @@ mod tests { #[test] fn test_pytime_from_iso() { Python::with_gil(|py| { - let cls = PyType::new_bound::(py); + let cls = PyType::new::(py); let expected = PyUtc::new(2000, 1, 1, 0, 0, 0.0).unwrap(); let actual = PyUtc::from_iso(&cls, "2000-01-01T00:00:00 UTC").unwrap(); assert_eq!(actual, expected); @@ -195,7 +195,7 @@ mod tests { #[should_panic(expected = "invalid ISO")] fn test_pytime_from_iso_invalid() { Python::with_gil(|py| { - let cls = PyType::new_bound::(py); + let cls = PyType::new::(py); let _ = PyUtc::from_iso(&cls, "2000-01-01X00:00:00 UTC").unwrap(); }) } diff --git a/data/pck00011_n0066.tpc b/data/pck00011_n0066.tpc new file mode 100644 index 00000000..604ca497 --- /dev/null +++ b/data/pck00011_n0066.tpc @@ -0,0 +1,4354 @@ +KPL/PCK + +P_constants (PCK) SPICE kernel file pck00011_n0066.tpc +=========================================================================== + + By: Nat Bachman (NAIF) 2022 December 27 + + +Data Accuracy Warning +-------------------------------------------------------- + + This file provides reduced accuracy Phobos rotation data compared + to those provided in the file + + pck00011.tpc. + + This reduction was needed to make this file usable with the N0066 and + older versions of the SPICE Toolkit. See the sections "Version + Description" and "Software limitations" below. + + All other data in this file match those provided in pck00011.tpc. + + +Purpose +-------------------------------------------------------- + + This file makes available for use in SPICE-based application + software orientation and size/shape data for natural bodies. The + principal source of the data is a published report by the IAU + Working Group on Cartographic Coordinates and Rotational Elements + [1]. + + Orientation and size/shape data not provided by this file may be + available in mission-specific PCK files. Such PCKs may be the + preferred data source for mission-related applications. + Mission-specific PCKs can be found in PDS archives or on the NAIF + web site at URL: + + https://naif.jpl.nasa.gov/naif/data.html + + +Version Description +-------------------------------------------------------- + + This file was created on December 27, 2022 by NASA's Navigation + and Ancillary Information Facility (NAIF) group, located at the Jet + Propulsion Laboratory, Pasadena, CA. + + This file contains the same data as the file + + pck00011.tpc + + except that in this file, data for the orientation of Phobos have + been modified, at the expense of some loss of accuracy, so that + the file is usable by the N0066 and older versions of the SPICE + Toolkit. + + Specifically, in this file, the polynomial defining the M5 phase + angle of the Mars system is truncated to first order, and all of + the phase angle polynomial coefficient sets for the Mars system + have two coefficients. Only the model of the orientation of Phobos + is affected by this change. + + Over the time period + + 2000 : 2040 + + the maximum angular error of Phobos' orientation relative to that + given by the original model is approximately 0.041 degrees. The + maximum error occurs at year 2040. + + The previous version of the file was + + pck00010.tpc + + That file was published October 21, 2011. + + This version incorporates data from sources listed under "Sources and + References" below. The primary sources are [1] and [2]. This file + contains size, shape, and orientation data for all objects covered + by the previous version of the file. + + New objects covered by this file but not by the previous + version are: + + Asteroid 52 Europa + Comet 67P/Churyumov-Gerasimenko + Aegaeon (Saturn LIII) + Comet Hartley 2 + Asteroid Psyche + + Orientation data for the following objects provided by this file differ + from those provided by the previous version: + + Mercury + + Mars + Deimos + Phobos + + Neptune + + Ceres + Steins + Vesta + + Borrelly + Tempel 1 + + Radii for the following objects provided by this file differ + from those provided by the previous version: + + Sun + + Mercury + + Anthe + Atlas + Calypso + Daphnis + Epimetheus + Helene + Janus + Methone + Pallene + Pan + Pandora + Prometheus + Telesto + + Pluto + Charon + + Itokawa + + +File Organization +-------------------------------------------------------- + + The contents of this file are as follows. + + Introductory Information: + + -- Purpose + + -- Version description + + -- File Organization + + -- Disclaimer + + -- Sources + + -- Explanatory notes + + -- Body numbers and names + + + PcK Data: + + + Orientation Data + ---------------- + + -- Orientation constants for the Sun, planets, and + Pluto. Additional items included in this section: + + - North geomagnetic centered dipole value + for the year 2023 + + -- Orientation constants for satellites + + -- Orientation constants for asteroids + + 52 Europa + Davida + Eros + Gaspra + Hartley 2 (data shown in comments only) + Ida + Itokawa + Lutetia + Pallas + Steins + Vesta + + -- Orientation constants for comets + + 19P/Borrelly + 67P/Churyumov-Gerasimenko + Hartley 2 (data shown in comments only) + 9P/Tempel 1 + + + Orientation data provided in this file are used + by the SPICE Toolkit to evaluate the orientation + of body-fixed, body-centered reference frames + with respect to the ICRF frame ("J2000" in + SPICE documentation). These body-fixed frames + have names of the form + + IAU_ + + for example + + IAU_JUPITER + + See the PCK Required Reading file pck.req for details. + + + + Radii of Bodies + --------------- + + -- Radii of Sun, planets, and Pluto + + -- Radii of satellites, where available + + -- Radii of asteroids + + 52 Europa + Ceres + Davida + Eros + Gaspra + Ida + Itokawa + Lutetia + Mathilde + Psyche + Steins + Toutatis + Vesta + + -- Radii of comets + + 19P/Borrelly + 67P/Churyumov-Gerasimenko + 81P/Wild 2 + 9P/Tempel 1 + Halley + Hartley 2 + + +Disclaimer +-------------------------------------------------------- + +Applicability of Data + + This P_constants file (PCK) may not contain the parameter values + that you prefer. NAIF suggests that you inspect this file visually + before proceeding with any critical or extended data processing. + +File Modifications by Users + + Note that this file may be readily modified by you to change + values or add/delete parameters. NAIF requests that you update the + "by line," date, version description section, and file name + if you modify this file. + + A user-modified file should be thoroughly tested before + being published or otherwise distributed. + + P_constants files must conform to the standards described + in the two SPICE technical reference documents: + + PCK Required Reading + Kernel Required Reading + + +Known Limitations and Caveats + + Accuracy + -------- + + In general, the orientation models given here are claimed by the + IAU Working Group Report [1] to be accurate to 0.1 degree + ([1], p. 9). However, NAIF notes that orientation models for + natural satellites and asteroids have in some cases changed + substantially with the availability of new observational data, so + users are urged to investigate the suitability for their + applications of the models presented here. + + Earth orientation + ----------------- + + The IAU report [1] no longer provides rotational elements for the + Earth. Data in this file are from [3]. + + NAIF strongly cautions against using the earth rotation model + presented here, corresponding to the SPICE reference frame name + IAU_EARTH, for work demanding high accuracy. This model has been + determined by NAIF to have an error in the prime meridian location + of magnitude at least 150 arcseconds, with a local minimum + occurring during the year 1999. Regarding availability of better + earth orientation data for use with the SPICE system: + + Earth orientation data are available from NAIF in the form of + binary earth PCK files. These files provide orientation data + for the ITRF93 (terrestrial) reference frame relative to the + ICRF. + + NAIF employs an automated process to create these files; each + time JPL's Tracking Systems and Applications Section produces a + new earth orientation parameter (EOP) file, a new PCK is + produced. These PCKs cover a roughly 23 year time span starting + at Jan. 1, 2000. In these PCK files, the following effects are + accounted for in modeling the earth's rotation: + + - Precession: 1976 IAU model + + - Nutation: 1980 IAU model, plus interpolated + EOP nutation corrections + + - Polar motion: interpolated from EOP file + + - True sidereal time: + + UT1 - UT1R (if needed): given by analytic formula + + TAI - UT1 (or UT1R): interpolated from EOP file + + UT1 - GMST: given by analytic formula + + equation of equinoxes: given by analytic formula + + where + + TAI = International Atomic Time + UT1 = Greenwich hour angle of computed mean sun - 12h + UT1R = Regularized UT1 + GMST = Greenwich mean sidereal time + + These kernels are available from the NAIF web site + + https://naif.jpl.nasa.gov/pub/naif/generic_kernels/pck + + At this time, these kernels have file names of the form + + earth_000101_yymmdd_yymmdd.bpc + + The first date in the file name, meaning 2000 January 1, is the + file's coverage begin time. The second and third dates are, + respectively, the file's coverage end time and the epoch of the + last datum. + + These binary PCK files are very accurate (error < 0.1 + microradian) for epochs preceding the epoch of the last datum. + For later epochs, the error rises to several microradians. + + Binary PCK files giving accurate earth orientation from 1972 to + 2007 and *low accuracy* predicted earth orientation from + 2020 to 2099 are also available in the same location. + + Characteristics and names of the binary kernels described here + are subject to change. See the aareadme.txt file at the URL + above for details. + + + Lunar orientation + ----------------- + + The IAU report [1] no longer provides rotational elements for the + Moon. Data in this file are from [3]. + + The lunar orientation formula provided by this file is a + trigonometric polynomial approximation yielding the orientation of + the lunar "Mean Earth/Polar Axis" (ME) reference frame. The + SPICE reference frame name corresponding to this model is + IAU_MOON. + + A more accurate approximation can be obtained by using both the + latest NAIF lunar frame kernel and the latest binary lunar orientation + PCK file. These files provide orientation data for the both the Mean + Earth/Polar Axis frame, which has the SPICE name MOON_ME, and the + Lunar Principal Axes frame, which has the SPICE name MOON_PA. + + These files are available on the NAIF web site; lunar PCKs are + located at the PCK URL above; lunar frame kernels are located at + + https://naif.jpl.nasa.gov/pub/naif/generic_kernels/fk/satellites + + The latest lunar frame kernel has a name of the form + + moon_dennn_yymmdd.tf + + The latest binary lunar PCK has a name of the form + + moon_pa_dennn_yymmdd.bpc + + See the "aareadme.txt" files in the paths shown above for details + on file contents and versions. We also suggest you refer to the + SPICE tutorial named "lunar_earth_pck-fk," which is available from + the NAIF web site. + + + Geomagnetic dipole + ------------------ + + The SPICE Toolkit doesn't currently contain software to model the + north geomagnetic centered dipole as a function of time. + As a convenience for users, this dipole's location at the + epoch 2023.0 was selected as a representative datum, and the + planetocentric longitude and latitude of this location have been + associated with the keywords + + BODY399_N_GEOMAG_CTR_DIPOLE_LON + BODY399_N_GEOMAG_CTR_DIPOLE_LAT + + Older values for the north geomagnetic centered dipole are + presented in comments as a discrete time series for the time range + 1945-2000. For details concerning the geomagnetic field model from + which these values were derived, including a discussion of the + model's accuracy, see [9] and [11]. + + + Prime meridian offsets + ---------------------- + + Prime meridian offset kernel variables, which have names + of the form + + BODYnnn_LONG_AXIS + + are not used by SPICE geometry software. These variables should be + considered deprecated; however, they will be retained for + backwards compatibility. + + Users wishing to specify an offset reflecting the orientation of a + reference ellipsoid relative to a body-fixed reference frame + specified here should do so by creating a constant-offset frame + (also called a "TK" frame) specification. See the Frames Required + Reading frames.req for details. + + The Mars prime meridian offset given by [6] is provided for + informational purposes only. + + + Software limitations + -------------------- + + SPICE Toolkits prior to version N0067 cannot make use of + the Mars system orientation data provided in the file + + pck00011.tpc + + These older Toolkits are unable to detect and signal a SPICE error if + they are used to compute orientation of Mars, Phobos, or Deimos + using these data: memory corruption will occur in user applications + linked these Toolkits if the applications attempt such computations. + Any results, including those of unrelated computations, may be invalid + after such memory corruption occurs. + + NAIF provides this PCK file + + pck00011_n0066.tpc + + for use with older Toolkits. In this file, one of the phase angle + polynomials for Phobos is truncated so as to be usable with older + Toolkits. See the "Version Description" above for details. + + +Sources and References +-------------------------------------------------------- + + Sources and background references for the constants listed in this + file are: + + + [1] Archinal, B.A., Acton, C.H., A'Hearn, M.F., Conrad, A., + Consolmagno, G.J., Duxbury, T., Hestroffer, D., Hilton, + J.L., Kirk, R.L., Klinoner, S.A., McCarthy, D., + Meech, K., Oberst, J., Ping., J., Seidelmann, P.K., Tholen, + D.J., Thomas, P.C., and Williams, I.P., "Report of the IAU + Working Group on Cartographic Coordinates and Rotational + Elements: 2015," Celestial Mechanics and Dynamical Astronomy + 130, Article number 22 (2018). + DOI: https://doi.org/10.1007/s10569-017-9805-5 + + [2] Archinal, B.A., Acton, C.H., Conrad, A., Duxbury, T., + Hestroffer, D., Hilton, J.L., Jorda, L., Kirk, R.L., + Klinoner, Margot, J.-L., S.A., Meech, K., Oberst, + Paganelli, F., J., Ping., J., Seidelmann, P.K., Stark, A., + Tholen, Wang, Y., and Williams, I.P., "Correction to: + Report of the IAU Working Group on Cartographic Coordinates + and Rotational Elements: 2015." + + [3] Archinal, B.A., A'Hearn, M.F., Bowell, E., Conrad, A., + Consolmagno, G.J., Courtin, R., Fukushima, T., + Hestroffer, D., Hilton, J.L., Krasinsky, G.A., + Neumann, G., Oberst, J., Seidelmann, P.K., Stooke, P., + Tholen, D.J., Thomas, P.C., and Williams, I.P. + "Report of the IAU Working Group on Cartographic Coordinates + and Rotational Elements: 2009." + + [4] Archinal, B.A., A'Hearn, M.F., Conrad, A., + Consolmagno, G.J., Courtin, R., Fukushima, T., + Hestroffer, D., Hilton, J.L., Krasinsky, G.A., + Neumann, G., Oberst, J., Seidelmann, P.K., Stooke, P., + Tholen, D.J., Thomas, P.C., and Williams, I.P. + "Erratum to: Reports of the IAU Working Group on + Cartographic Coordinates and Rotational Elements: 2006 & + 2009." + + [5] Seidelmann, P.K., Archinal, B.A., A'Hearn, M.F., + Conrad, A., Consolmagno, G.J., Hestroffer, D., + Hilton, J.L., Krasinsky, G.A., Neumann, G., + Oberst, J., Stooke, P., Tedesco, E.F., Tholen, D.J., + and Thomas, P.C. "Report of the IAU/IAG Working Group + on Cartographic Coordinates and Rotational Elements: 2006." + + [6] Duxbury, Thomas C. (2001). "IAU/IAG 2000 Mars Cartographic + Conventions," presentation to the Mars Express Data + Archive Working Group, Dec. 14, 2001. + + [7] Russell, C.T. and Luhmann, J.G. (1990). "Earth: Magnetic + Field and Magnetosphere." . Originally + published in "Encyclopedia of Planetary Sciences," J.H. + Shirley and R.W. Fainbridge, eds. Chapman and Hall, + New York, pp 208-211. + + [8] Russell, C.T. (1971). "Geophysical Coordinate + Transformations," Cosmic Electrodynamics 2 184-186. + NAIF document 181.0. + + [9] ESA/ESTEC Space Environment Information System (SPENVIS) + (2003). Web page: "Dipole approximations of the + geomagnetic field." . + + [10] Davies, M.E., Abalakin, V.K., Bursa, M., Hunt, G.E., + and Lieske, J.H. (1989). "Report of the IAU/IAG/COSPAR + Working Group on Cartographic Coordinates and Rotational + Elements of the Planets and Satellites: 1988," Celestial + Mechanics and Dynamical Astronomy, v.46, no.2, pp. + 187-204. + + [11] International Association of Geomagnetism and Aeronomy + Web page: "International Geomagnetic Reference Field." + Discussion URL: + + http://www.ngdc.noaa.gov/IAGA/vmod/igrf.html + + Coefficients URL: + + https://www.ngdc.noaa.gov/IAGA/vmod/coeffs/igrf13coeffs.txt + + [12] Email communication from Dr. Brent Archinal (IAU WGCCRE Chair, + USGS): "Re: Shape of comet Hartley 2." Dated December 22, 2022. + + [13] Seidelmann, P.K., Archinal, B.A., A'Hearn, M.F., + Cruikshank, D.P., Hilton, J.L., Keller, H.U., Oberst, J., + Simon, J.L., Stooke, P., Tholen, D.J., and Thomas, P.C. + "Report of the IAU/IAG Working Group on Cartographic + Coordinates and Rotational Elements of the Planets and + Satellites: 2003," Unpublished. + + + Most values are from [1]. All exceptions are + commented where they occur in this file. The exceptions are: + + -- Phobos prime meridian constants are from [2]. + + -- Lunar orientation data are from [3]. + + -- Earth orientation data are from [3]. + + -- North geomagnetic centered dipole values were + computed by Nat Bachman from the 13th generation IGRF. + The data source was [11]. + + "Old values" listed are from the SPICE PCK file pck00010.tpc + dated October 21, 2011. Most of these values came from the 2009 + IAU report [3]. + + + +Explanatory Notes +-------------------------------------------------------- + + This file, which is logically part of the SPICE P-kernel, contains + constants used to model the orientation, size and shape of the + Sun, planets, natural satellites, and selected comets and + asteroids. The orientation models express the direction of the + pole and location of the prime meridian of a body as a function of + time. The size/shape models ("shape models" for short) represent + all bodies as ellipsoids, using two equatorial radii and a polar + radius. Spheroids and spheres are obtained when two or all three + radii are equal. + + The SPICE Toolkit routines that use this file are documented in + the SPICE "Required Reading" file pck.req. They are also + documented in the "PCK" SPICE tutorial, which is available on + the NAIF web site. + +File Format + + A terse description of the PCK file format is given here. See the + SPICE "Required Reading" files pck.req and kernel.req for a + detailed explanation of the SPICE text kernel file format. The + files pck.req and kernel.req are included in the documentation + provided with the SPICE Toolkit. + + The file starts out with the ``ID word'' string + + KPL/PCK + + This string identifies the file as a text kernel containing PCK + data. + + This file consists of a series of comment blocks and data blocks. + Comment blocks, which contain free-form descriptive or explanatory + text, are preceded by a \begintext token. Data blocks follow a + \begindata token. In order to be recognized, each of these tokens + must be placed on a line by itself. + + The portion of the file preceding the first data block is treated + as a comment block; it doesn't require an initial \begintext + token. + + This file identifies data using a series of + + KEYWORD = VALUE + + assignments. The left hand side of each assignment is a + "kernel variable" name; the right hand side is an associated value + or list of values. SPICE kernel pool access routines (see kernel.req) + enable other SPICE routines and user applications to retrieve the + set of values associated with each kernel variable name. + + Kernel variable names are case-sensitive and are limited to + 32 characters in length. + + Numeric values may be integer or floating point. String values + are normally limited to 80 characters in length; however, SPICE + provides a mechanism for identifying longer, "continued" strings. + See the SPICE routine STPOOL for details. + + String values are single quoted. + + When the right hand side of an assignment is a list of values, + the list items may be separated by commas or simply by blanks. + The list must be bracketed by parentheses. Example: + + BODY399_RADII = ( 6378.1366 6378.1366 6356.7519 ) + + Any blanks preceding or following keyword names, values and equal + signs are ignored. + + Assignments may be spread over multiple lines, for example: + + BODY399_RADII = ( 6378.1366 + 6378.1366 + 6356.7519 ) + + This file may contain blank lines anywhere. Non-printing + characters including TAB should not be present in the file: the + presence of such characters may cause formatting errors when the + file is viewed. + +Time systems and reference frames + + The 2015 IAU Working Group Report [1] states the time scale used + as the independent variable for the rotation formulas is + Barycentric Dynamical Time (TDB) and that the epoch of variable + quantities is J2000 TDB (2000 Jan 1 12:00:00 TDB, Julian ephemeris + date 2451545.0 TDB). Throughout SPICE documentation and in this + file, we use the names "J2000 TDB" and "J2000" for this epoch. The + name "J2000.0" is equivalent. + + SPICE documentation refers to the time system used in this file + as either "ET" or "TDB." SPICE software makes no distinction + between TDB and the time system associated with the independent + variable of the JPL planetary ephemerides T_eph. + + The inertial reference frame used for the rotational elements in + this file is identified by [1] as the ICRF (International + Celestial Reference Frame). + + The SPICE PCK software that reads this file uses the label "J2000" + to refer to the ICRF; this is actually a mislabeling which has + been retained in the interest of backward compatibility. Using + data from this file, by means of calls to the SPICE frame + transformation routines, will actually compute orientation + relative to the ICRF. + + The difference between the J2000 frame and the ICRF is + on the order of 100 milliarcseconds and is well below the + accuracy level of the formulas in this file. + +Orientation models + + All of the complete orientation models use three Euler angles to + describe the orientation of the coordinate axes of the "Body Equator + and Prime Meridian" system with respect to an inertial system. By + default, the inertial system is the ICRF (labeled as "J2000"), but + other inertial frames can be specified in the file. See the PCK + Required Reading for details. + + The first two angles, in order, are the ICRF right ascension and + declination (henceforth RA and DEC) of the north pole of a body as + a function of time. The third angle is the prime meridian location + (represented by "W"), which is expressed as a rotation about the + north pole, and is also a function of time. + + For each body, the expressions for the north pole's right + ascension and declination, as well as prime meridian location, are + sums (as far as the models that appear in this file are concerned) + of quadratic polynomials and trigonometric polynomials, where the + independent variable is time. + + In this file, the time arguments in expressions always refer to + Barycentric Dynamical Time (TDB), measured in centuries or days + past a reference epoch. By default, the reference epoch is the + J2000 epoch, which is Julian ephemeris date 2451545.0 (2000 Jan 1 + 12:00:00 TDB), but other epochs can be specified in the file. See + the PCK Required Reading for details. + + Orientation models for satellites and some planets (including + Jupiter) involve both polynomial terms and trigonometric terms. + The arguments of the trigonometric terms are linear or quadratic + polynomials. In this file, we call the arguments of these + trigonometric terms "nutation precession angles" or "phase angles." + + Example: 2015 IAU Model for orientation of Jupiter. Note that + these values are used as an example only; see the data area below + for current values. + + Right ascension + --------------- + + alpha = 268.056595 - 0.006499 T + 0.000117 sin(Ja) + 0 + 0.000938 sin(Jb) + 0.001432 sin(Jc) + + 0.000030 sin(Jd) + 0.002150 sin(Je) + + Declination + ----------- + + delta = 64.495303 + 0.002413 T + 0.000050 cos(Ja) + 0 + 0.000404 cos(Jb) + 0.000617 cos(Jc) + - 0.000013 cos(Jd) + 0.000926 cos(Je) + + Prime meridian + -------------- + + W = 284.95 + 870.5366420 d + + + Here + + T represents centuries past J2000 ( TDB ), + + d represents days past J2000 ( TDB ). + + Ja-Je are nutation precession angles. + + In this file, the polynomials' coefficients above are assigned + to kernel variable names (left-hand-side symbols) as follows + + BODY599_POLE_RA = ( 268.056595 -0.006499 0. ) + BODY599_POLE_DEC = ( 64.495303 0.002413 0. ) + BODY599_PM = ( 284.95 870.5360000 0. ) + + and the trigonometric polynomials' coefficients are assigned + as follows + + BODY599_NUT_PREC_RA = ( 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.000117 + 0.000938 + 0.001432 + 0.000030 + 0.002150 ) + + BODY599_NUT_PREC_DEC = ( 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.000050 + 0.000404 + 0.000617 + -0.000013 + 0.000926 ) + + BODY599_NUT_PREC_PM = ( 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.0 + 0.0 + 0.0 + 0.0 + 0.0 ) + + Note the number "599"; this is the NAIF ID code for Jupiter. + + In this file, the polynomial expressions for the nutation + precession angles are listed along with the planet's RA, DEC, and + prime meridian terms. Below are the 2006 IAU nutation precession + angles for the Jupiter system. + + J1 = 73.32 + 91472.9 T + J2 = 24.62 + 45137.2 T + J3 = 283.90 + 4850.7 T + J4 = 355.80 + 1191.3 T + J5 = 119.90 + 262.1 T + J6 = 229.80 + 64.3 T + J7 = 352.25 + 2382.6 T + J8 = 113.35 + 6070.0 T + + J9 = 146.64 + 182945.8 T + J10 = 49.24 + 90274.4 T + + Ja = 99.360714 + 4850.4046 T + Jb = 175.895369 + 1191.9605 T + Jc = 300.323162 + 262.5475 T + Jd = 114.012305 + 6070.2476 T + Je = 49.511251 + 64.3000 T + + Here + + T represents centuries past J2000 ( TDB ) + + J1-J10 and Ja-Je are the nutation precession angles. The angles + J9 and J10 are equal to 2*J1 and 2*J2, respectively. + + Angles J9 and J10 are not present in [1]; they have been added + to fit the terms 2*J1 and 2*J2, which appear in the orientation + models of several satellites, into a form that can be accepted + by the PCK system. + + The assignment of the nutation precession angles for the + Jupiter system is as follows: + + BODY5_NUT_PREC_ANGLES = ( 73.32 91472.9 + 24.62 45137.2 + 283.90 4850.7 + 355.80 1191.3 + 119.90 262.1 + 229.80 64.3 + 352.25 2382.6 + 113.35 6070.0 + 146.64 182945.8 + 49.24 90274.4 + 99.360714 4850.4046 + 175.895369 1191.9605 + 300.323162 262.5475 + 114.012305 6070.2476 + 49.511251 64.3000 ) + + You'll see an additional symbol grouped with the ones listed + above; it is + + BODY599_LONG_AXIS + + This is a deprecated feature; see the note on "Prime meridian + offsets" under "Known Limitations and Caveats" above. + + The pattern of the formulas for satellite orientation is similar + to that for Jupiter. Example: 2006 IAU values for Io. Again, these + values are used as an example only; see the data area below for + current values. + + Right ascension + --------------- + + alpha = 268.05 - 0.009 T + 0.094 sin(J3) + 0.024 sin(J4) + 0 + + Declination + ----------- + + delta = 64.50 + 0.003 T + 0.040 cos(J3) + 0.011 cos(J4) + 0 + + Prime meridian + -------------- + + W = 200.39 + 203.4889538 d - 0.085 sin(J3) - 0.022 sin(J4) + + + d represents days past J2000. + + J3 and J4 are nutation precession angles. + + The polynomial terms are assigned to symbols by the statements + + BODY501_POLE_RA = ( 268.05 -0.009 0. ) + BODY501_POLE_DEC = ( 64.50 0.003 0. ) + BODY501_PM = ( 200.39 203.4889538 0. ) + + The coefficients of the trigonometric terms are assigned to symbols by + the statements + + BODY501_NUT_PREC_RA = ( 0. 0. 0.094 0.024 ) + BODY501_NUT_PREC_DEC = ( 0. 0. 0.040 0.011 ) + BODY501_NUT_PREC_PM = ( 0. 0. -0.085 -0.022 ) + + 501 is the NAIF ID code for Io. + + SPICE software expects the models for satellite orientation to + follow the form of the model shown here: the polynomial portions of the + RA, DEC, and W expressions are expected to be quadratic, the + trigonometric terms for RA and W (satellite prime meridian) are expected + to be linear combinations of sines of nutation precession angles, the + trigonometric terms for DEC are expected to be linear combinations of + cosines of nutation precession angles, and the polynomials for the + nutation precession angles themselves are expected to be linear or + quadratic. + + Eventually, the software will handle more complex expressions, we + expect. + + +Shape models + + There is only one kind of shape model supported by the SPICE + Toolkit software at present: the triaxial ellipsoid. The 2015 IAU + report [1] does not use any other models, except in the case of + Mars, where separate values are given for the north and south + polar radii. In this file, we provide as a datum the mean Mars + polar radius provided by [1]. The North and South values are + included as comments. + + For each body, three radii are listed: The first number is + the largest equatorial radius, the second number is the smaller + equatorial radius, and the third is the polar radius. + + Example: Radii of the Earth. + + BODY399_RADII = ( 6378.1366 6378.1366 6356.7519 ) + + + +Body Numbers and Names +-------------------------------------------------------- + + + The following NAIF body ID codes and body names appear in this + file. See the NAIF IDs Required Reading file naif_ids.req for + a detailed discussion and a complete list of ID codes and names. + + + 1 Mercury barycenter + 2 Venus barycenter + 3 Earth barycenter + 4 Mars barycenter + 5 Jupiter barycenter + 6 Saturn barycenter + 7 Uranus barycenter + 8 Neptune barycenter + 9 Pluto barycenter + 10 Sun + + + 199 Mercury + + + 299 Venus + + + 399 Earth + + 301 Moon + + + 499 Mars + + 401 Phobos 402 Deimos + + + 599 Jupiter + + 501 Io 502 Europa 503 Ganymede 504 Callisto + 505 Amalthea 506 Himalia 507 Elara 508 Pasiphae + 509 Sinope 510 Lysithea 511 Carme 512 Ananke + 513 Leda 514 Thebe 515 Adrastea 516 Metis + + + 699 Saturn + + 601 Mimas 602 Enceladus 603 Tethys 604 Dione + 605 Rhea 606 Titan 607 Hyperion 608 Iapetus + 609 Phoebe 610 Janus 611 Epimetheus 612 Helene + 613 Telesto 614 Calypso 615 Atlas 616 Prometheus + 617 Pandora 618 Pan 632 Methone 633 Pallene + 634 Polydeuces 635 Daphnis 649 Anthe 653 Aegaeon + + + 799 Uranus + + 701 Ariel 702 Umbriel 703 Titania 704 Oberon + 705 Miranda 706 Cordelia 707 Ophelia 708 Bianca + 709 Cressida 710 Desdemona 711 Juliet 712 Portia + 713 Rosalind 714 Belinda 715 Puck + + + 899 Neptune + + 801 Triton 802 Nereid 803 Naiad 804 Thalassa + 805 Despina 806 Galatea 807 Larissa 808 Proteus + + + 999 Pluto + + 901 Charon + + + 1000005 Comet 19P/Borrelly + 1000012 Comet 67P/Churyumov-Gerasimenko + 1000036 Comet Halley + 1000041 Comet Hartley 2 + 1000093 Comet 9P/Tempel 1 + 1000107 Comet 81P/Wild 2 + + 2000001 Asteroid Ceres + 2000002 Asteroid Pallas + 2000016 Asteroid Psyche + 2000004 Asteroid Vesta + 2000021 Asteroid Lutetia + 2000052 Asteroid 52 Europa + 2000216 Asteroid Kleopatra + 2000253 Asteroid Mathilde + 2000433 Asteroid Eros + 2000511 Asteroid Davida + 2002867 Asteroid Steins + 2004179 Asteroid Toutatis + 2025143 Asteroid Itokawa + 2431010 Asteroid Ida + 9511010 Asteroid Gaspra + + +Orientation Constants for the Sun and Planets +-------------------------------------------------------- + + +Sun + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + \begindata + + BODY10_POLE_RA = ( 286.13 0. 0. ) + BODY10_POLE_DEC = ( 63.87 0. 0. ) + BODY10_PM = ( 84.176 14.18440 0. ) + BODY10_LONG_AXIS = ( 0. ) + +\begintext + +Mercury + + Old values: + + Values are from the 2009 IAU report. + + + body199_pole_ra = ( 281.0097 -0.0328 0. ) + body199_pole_dec = ( 61.4143 -0.0049 0. ) + body199_pm = ( 329.5469 6.1385025 0. ) + + body199_long_axis = ( 0. ) + + body199_nut_prec_ra = ( 0. 0. 0. 0. 0. ) + + body199_nut_prec_dec = ( 0. 0. 0. 0. 0. ) + + body199_nut_prec_pm = ( 0.00993822 + -0.00104581 + -0.00010280 + -0.00002364 + -0.00000532 ) + + + Current values: + +\begindata + + BODY199_POLE_RA = ( 281.0103 -0.0328 0. ) + BODY199_POLE_DEC = ( 61.4155 -0.0049 0. ) + BODY199_PM = ( 329.5988 6.1385108 0. ) + + BODY199_LONG_AXIS = ( 0. ) + + BODY199_NUT_PREC_RA = ( 0. 0. 0. 0. 0. ) + + BODY199_NUT_PREC_DEC = ( 0. 0. 0. 0. 0. ) + + BODY199_NUT_PREC_PM = ( 0.01067257 + -0.00112309 + -0.00011040 + -0.00002539 + -0.00000571 ) +\begintext + + The linear coefficients have been scaled up from degrees/day + to degrees/century, because the SPICELIB PCK reader expects + these units. The original constants were: + + 174.7910857 4.092335 + 349.5821714 8.184670 + 164.3732571 12.277005 + 339.1643429 16.369340 + 153.9554286 20.461675 + +\begindata + + BODY1_NUT_PREC_ANGLES = ( 174.7910857 0.14947253587500003E+06 + 349.5821714 0.29894507175000006E+06 + 164.3732571 0.44841760762500006E+06 + 339.1643429 0.59789014350000012E+06 + 153.9554286 0.74736267937499995E+06 ) + +\begintext + + +Venus + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY299_POLE_RA = ( 272.76 0. 0. ) + BODY299_POLE_DEC = ( 67.16 0. 0. ) + BODY299_PM = ( 160.20 -1.4813688 0. ) + + BODY299_LONG_AXIS = ( 0. ) + +\begintext + + +Earth + + Old values: + + The values shown below are those from the 2009 IAU report. The 2015 + report does not provide orientation data for the Earth or Moon. + +\begindata + + BODY399_POLE_RA = ( 0. -0.641 0. ) + BODY399_POLE_DEC = ( 90. -0.557 0. ) + BODY399_PM = ( 190.147 360.9856235 0. ) + BODY399_LONG_AXIS = ( 0. ) + +\begintext + + + Nutation precession angles for the Earth-Moon system: + + The linear coefficients have been scaled up from degrees/day + to degrees/century, because the SPICELIB PCK reader expects + these units. The original constants were: + + 125.045D0 -0.0529921D0 + 250.089D0 -0.1059842D0 + 260.008D0 13.0120009D0 + 176.625D0 13.3407154D0 + 357.529D0 0.9856003D0 + 311.589D0 26.4057084D0 + 134.963D0 13.0649930D0 + 276.617D0 0.3287146D0 + 34.226D0 1.7484877D0 + 15.134D0 -0.1589763D0 + 119.743D0 0.0036096D0 + 239.961D0 0.1643573D0 + 25.053D0 12.9590088D0 + + +\begindata + + + BODY3_NUT_PREC_ANGLES = ( 125.045 -1935.5364525000 + 250.089 -3871.0729050000 + 260.008 475263.3328725000 + 176.625 487269.6299850000 + 357.529 35999.0509575000 + 311.589 964468.4993100000 + 134.963 477198.8693250000 + 276.617 12006.3007650000 + 34.226 63863.5132425000 + 15.134 -5806.6093575000 + 119.743 131.8406400000 + 239.961 6003.1503825000 + 25.053 473327.7964200000 ) + + +\begintext + + + North geomagnetic centered dipole: + + The north dipole location is time-varying. The values shown + below, taken from [9], represent a discrete sampling of the + north dipole location from 1945 to 2000. The terms DGRF and + IGRF refer to, respectively, "Definitive Geomagnetic + Reference Field" and "International Geomagnetic Reference + Field." See references [9] and [11] for details. + + Coordinates are planetocentric. + + Data source Lat Lon + ----------- ----- ------ + DGRF 1945 78.47 291.47 + DGRF 1950 78.47 291.15 + DGRF 1955 78.46 290.84 + DGRF 1960 78.51 290.53 + DGRF 1965 78.53 290.15 + DGRF 1970 78.59 289.82 + DGRF 1975 78.69 289.53 + DGRF 1980 78.81 289.24 + DGRF 1985 78.97 289.10 + DGRF 1990 79.13 288.89 + IGRF 1995 79.30 288.59 + IGRF 2000 79.54 288.43 + + Original values: + + Values are from [8]. Note the year of publication was 1971. + + body399_mag_north_pole_lon = ( -69.761 ) + body399_mag_north_pole_lat = ( 78.565 ) + + Previous values: + + body399_n_geomag_ctr_dipole_lon = ( 287.62 ) + body399_n_geomag_ctr_dipole_lat = ( 80.13 ) + + Current values: + + Values are given for the epoch 2023.0 and were derived + by Nat Bachman from constants taken from IGRF-13. See [11]. + +\begindata + + BODY399_N_GEOMAG_CTR_DIPOLE_LON = ( 287.34 ) + BODY399_N_GEOMAG_CTR_DIPOLE_LAT = ( 80.74 ) + +\begintext + + +Mars + + Old values: + + Values are from the 2009 IAU report. + + body499_pole_ra = ( 317.68143 -0.1061 0. ) + body499_pole_dec = ( 52.88650 -0.0609 0. ) + body499_pm = ( 176.630 350.89198226 0. ) + + body499_long_axis = ( 252. ) + + Below, the linear terms are scaled by 36525.0: + + -0.4357640000000000 --> -15916.28010000000 + 1128.409670000000 --> 41215163.19675000 + -1.8151000000000000E-02 --> -662.9652750000000 + + We also introduce a fourth nutation precession angle, which + is the pi/2-complement of the third angle. This angle is used + in computing the prime meridian location for Deimos. See the + discussion of this angle below in the section containing orientation + constants for Deimos. + + body4_nut_prec_angles = ( 169.51 -15916.2801 + 192.93 41215163.19675 + 53.47 -662.965275 + 36.53 662.965275 ) + + + Current values: + +\begindata + + BODY499_POLE_RA = ( 317.269202 -0.10927547 0. ) + BODY499_POLE_DEC = ( 54.432516 -0.05827105 0. ) + BODY499_PM = ( 176.049863 +350.891982443297 0. ) + + BODY499_NUT_PREC_RA = ( 0 0 0 0 0 + 0 0 0 0 0 + 0.000068 + 0.000238 + 0.000052 + 0.000009 + 0.419057 ) + + + BODY499_NUT_PREC_DEC = ( 0 0 0 0 0 + 0 0 0 0 0 + 0 0 0 0 0 + 0.000051 + 0.000141 + 0.000031 + 0.000005 + 1.591274 ) + + + BODY499_NUT_PREC_PM = ( 0 0 0 0 0 + 0 0 0 0 0 + 0 0 0 0 0 + 0 0 0 0 0 + 0.000145 + 0.000157 + 0.000040 + 0.000001 + 0.000001 + 0.584542 ) + +\begintext + + SPICE support for quadratic phase angle polynomials + was introduced in the N0067 Toolkit version. Older Toolkits + cannot use the constants for the Mars phase angles + given by [1]. In this file, the polynomial for the M5 + phase angle has been truncated to first order. Only + the model of the orientation of Phobos is degraded by this + change. + + See the SPICE server at + + https://naif.jpl.nasa.gov/naif/ + + for the file pck00011.tpc, which has the original model + given by [1]. + +\begindata + + BODY4_NUT_PREC_ANGLES = ( + + 190.72646643 15917.10818695 + 21.46892470 31834.27934054 + 332.86082793 19139.89694742 + 394.93256437 38280.79631835 + 189.63271560 41215158.18420050 + + 121.46893664 660.22803474 + 231.05028581 660.99123540 + 251.37314025 1320.50145245 + 217.98635955 38279.96125550 + 196.19729402 19139.83628608 + + 198.991226 19139.4819985 + 226.292679 38280.8511281 + 249.663391 57420.7251593 + 266.183510 76560.6367950 + 79.398797 0.5042615 + + 122.433576 19139.9407476 + 43.058401 38280.8753272 + 57.663379 57420.7517205 + 79.476401 76560.6495004 + 166.325722 0.5042615 + + 129.071773 19140.0328244 + 36.352167 38281.0473591 + 56.668646 57420.9295360 + 67.364003 76560.2552215 + 104.792680 95700.4387578 + 95.391654 0.5042615 ) + +\begintext + + +Jupiter + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + The number of nutation precession angles is 15. The ninth and + tenth are twice the first and second, respectively. The + eleventh through fifteenth correspond to angles JA-JE in + the 2015 IAU report. + +\begindata + + + BODY599_POLE_RA = ( 268.056595 -0.006499 0. ) + BODY599_POLE_DEC = ( 64.495303 0.002413 0. ) + BODY599_PM = ( 284.95 870.5360000 0. ) + BODY599_LONG_AXIS = ( 0. ) + + BODY599_NUT_PREC_RA = ( 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.000117 + 0.000938 + 0.001432 + 0.000030 + 0.002150 ) + + BODY599_NUT_PREC_DEC = ( 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.000050 + 0.000404 + 0.000617 + -0.000013 + 0.000926 ) + + BODY599_NUT_PREC_PM = ( 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.0 + 0.0 + 0.0 + 0.0 + 0.0 ) + + + BODY5_NUT_PREC_ANGLES = ( 73.32 91472.9 + 24.62 45137.2 + 283.90 4850.7 + 355.80 1191.3 + 119.90 262.1 + 229.80 64.3 + 352.25 2382.6 + 113.35 6070.0 + 146.64 182945.8 + 49.24 90274.4 + 99.360714 4850.4046 + 175.895369 1191.9605 + 300.323162 262.5475 + 114.012305 6070.2476 + 49.511251 64.3000 ) +\begintext + + +Saturn + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY699_POLE_RA = ( 40.589 -0.036 0. ) + BODY699_POLE_DEC = ( 83.537 -0.004 0. ) + BODY699_PM = ( 38.90 810.7939024 0. ) + BODY699_LONG_AXIS = ( 0. ) + +\begintext + + The first six angles given here are the angles S1 + through S6 from the 2015 IAU report; the seventh and + eighth angles are 2*S1 and 2*S2, respectively. + + +\begindata + + BODY6_NUT_PREC_ANGLES = ( 353.32 75706.7 + 28.72 75706.7 + 177.40 -36505.5 + 300.00 -7225.9 + 316.45 506.2 + 345.20 -1016.3 + 706.64 151413.4 + 57.44 151413.4 ) +\begintext + + +Uranus + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY799_POLE_RA = ( 257.311 0. 0. ) + BODY799_POLE_DEC = ( -15.175 0. 0. ) + BODY799_PM = ( 203.81 -501.1600928 0. ) + BODY799_LONG_AXIS = ( 0. ) + +\begintext + + The first 16 angles given here are the angles U1 + through U16 from the 2000 report; the 17th and + 18th angles are 2*U11 and 2*U12, respectively. + +\begindata + + BODY7_NUT_PREC_ANGLES = ( 115.75 54991.87 + 141.69 41887.66 + 135.03 29927.35 + 61.77 25733.59 + 249.32 24471.46 + 43.86 22278.41 + 77.66 20289.42 + 157.36 16652.76 + 101.81 12872.63 + 138.64 8061.81 + 102.23 -2024.22 + 316.41 2863.96 + 304.01 -51.94 + 308.71 -93.17 + 340.82 -75.32 + 259.14 -504.81 + 204.46 -4048.44 + 632.82 5727.92 ) + +\begintext + + + +Neptune + + Old values are from the 2009 IAU report: + + + body899_pole_ra = ( 299.36 0. 0. ) + body899_pole_dec = ( 43.46 0. 0. ) + body899_pm = ( 253.18 536.3128492 0. ) + body899_long_axis = ( 0. ) + + + body899_nut_prec_ra = ( 0.70 0. 0. 0. 0. 0. 0. 0. ) + body899_nut_prec_dec = ( -0.51 0. 0. 0. 0. 0. 0. 0. ) + body899_nut_prec_pm = ( -0.48 0. 0. 0. 0. 0. 0. 0. ) + + + Current values: + +\begindata + + BODY899_POLE_RA = ( 299.36 0. 0. ) + BODY899_POLE_DEC = ( 43.46 0. 0. ) + BODY899_PM = ( 249.978 541.1397757 0. ) + BODY899_LONG_AXIS = ( 0. ) + + + BODY899_NUT_PREC_RA = ( 0.70 0. 0. 0. 0. 0. 0. 0. ) + BODY899_NUT_PREC_DEC = ( -0.51 0. 0. 0. 0. 0. 0. 0. ) + BODY899_NUT_PREC_PM = ( -0.48 0. 0. 0. 0. 0. 0. 0. ) + +\begintext + + The 2015 IAU report defines the nutation precession angles + + N, N1, N2, ... , N7 + + and also uses the multiples of N1 and N7 + + 2*N1 + + and + + 2*N7, 3*N7, ..., 9*N7 + + In this file, we treat the angles and their multiples as + separate angles. In the kernel variable + + BODY8_NUT_PREC_ANGLES + + the order of the angles is + + N, N1, N2, ... , N7, 2*N1, 2*N7, 3*N7, ..., 9*N7 + + Each angle is defined by a linear polynomial, so two + consecutive array elements are allocated for each + angle. The first term of each pair is the constant term, + the second is the linear term. + +\begindata + + BODY8_NUT_PREC_ANGLES = ( 357.85 52.316 + 323.92 62606.6 + 220.51 55064.2 + 354.27 46564.5 + 75.31 26109.4 + 35.36 14325.4 + 142.61 2824.6 + 177.85 52.316 + 647.840 125213.200 + 355.700 104.632 + 533.550 156.948 + 711.400 209.264 + 889.250 261.580 + 1067.100 313.896 + 1244.950 366.212 + 1422.800 418.528 + 1600.650 470.844 ) + +\begintext + + + + +Orientation Constants for the Dwarf Planet Pluto +-------------------------------------------------------- + +Pluto + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY999_POLE_RA = ( 132.993 0. 0. ) + BODY999_POLE_DEC = ( -6.163 0. 0. ) + BODY999_PM = ( 302.695 56.3625225 0. ) + BODY999_LONG_AXIS = ( 0. ) + +\begintext + + + + +Orientation constants for the satellites +-------------------------------------------------------- + + +Satellites of Earth + + Old values: + + The values shown below are those from the 2009 IAU report. The 2015 + report does not provide orientation data for the Earth or Moon. + +\begindata + + + BODY301_POLE_RA = ( 269.9949 0.0031 0. ) + BODY301_POLE_DEC = ( 66.5392 0.0130 0. ) + BODY301_PM = ( 38.3213 13.17635815 -1.4D-12 ) + BODY301_LONG_AXIS = ( 0. ) + + BODY301_NUT_PREC_RA = ( -3.8787 -0.1204 0.0700 -0.0172 + 0.0 0.0072 0.0 0.0 + 0.0 -0.0052 0.0 0.0 + 0.0043 ) + + BODY301_NUT_PREC_DEC = ( 1.5419 0.0239 -0.0278 0.0068 + 0.0 -0.0029 0.0009 0.0 + 0.0 0.0008 0.0 0.0 + -0.0009 ) + + BODY301_NUT_PREC_PM = ( 3.5610 0.1208 -0.0642 0.0158 + 0.0252 -0.0066 -0.0047 -0.0046 + 0.0028 0.0052 0.0040 0.0019 + -0.0044 ) +\begintext + + + +Satellites of Mars + + + Phobos + + Old values are from the 2009 IAU report. + + + body401_pole_ra = ( 317.68 -0.108 0. ) + body401_pole_dec = ( 52.90 -0.061 0. ) + body401_pm = ( 35.06 1128.8445850 6.6443009930565219e-09 ) + + body401_long_axis = ( 0. ) + + body401_nut_prec_ra = ( 1.79 0. 0. 0. ) + body401_nut_prec_dec = ( -1.08 0. 0. 0. ) + body401_nut_prec_pm = ( -1.42 -0.78 0. 0. ) + + The quadratic prime meridian term is scaled by 1/36525**2: + + 8.864000000000000 ---> 6.6443009930565219E-09 + + + Current values: + + Values from the 2015 IAU report [1] were corrected by [2], which + is used as the source for the data below. + + The quadratic prime meridian term is scaled by 1/36525**2: + + 12.72192797000000000000 ---> 9.536137031212154e-09 + +\begindata + + BODY401_POLE_RA = ( 317.67071657 -0.10844326 0. ) + BODY401_POLE_DEC = ( 52.88627266 -0.06134706 0. ) + BODY401_PM = ( 35.18774440 1128.84475928 + 9.536137031212154e-09 ) + + BODY401_LONG_AXIS = ( 0. ) + + BODY401_NUT_PREC_RA = ( -1.78428399 + 0.02212824 + -0.01028251 + -0.00475595 ) + + + + BODY401_NUT_PREC_DEC = ( -1.07516537 + 0.00668626 + -0.00648740 + 0.00281576 ) + + + BODY401_NUT_PREC_PM = ( 1.42421769 + -0.02273783 + 0.00410711 + 0.00631964 + -1.143 ) + +\begintext + + + Deimos + + Old values: + + Values are from the 2009 IAU report. + + + The Deimos prime meridian expression from that report is: + + + 2 + W = 79.41 + 285.1618970 d - 0.520 T - 2.58 sin M + 3 + + + 0.19 cos M . + 3 + + At the present time, the PCK kernel software (the routine + BODEUL in particular) cannot handle the cosine term directly, + but we can represent it as + + 0.19 sin M + 4 + + where + + M = 90.D0 - M + 4 3 + + Therefore, the old nutation precession angle assignments for Phobos + and Deimos contain four coefficients rather than three. + + The quadratic prime meridian term is scaled by 1/36525**2: + + -0.5200000000000000 ---> -3.8978300049519307E-10 + + + body402_pole_ra = ( 316.65 -0.108 0. ) + body402_pole_dec = ( 53.52 -0.061 0. ) + body402_pm = ( 79.41 285.1618970 -3.897830d-10 ) + body402_long_axis = ( 0. ) + + body402_nut_prec_ra = ( 0. 0. 2.98 0. ) + body402_nut_prec_dec = ( 0. 0. -1.78 0. ) + body402_nut_prec_pm = ( 0. 0. -2.58 0.19 ) + + + New values: + +\begindata + + BODY402_POLE_RA = ( 316.65705808 -0.10518014 0. ) + BODY402_POLE_DEC = ( 53.50992033 -0.05979094 0. ) + + BODY402_PM = ( 79.39932954 285.16188899 0. ) + BODY402_LONG_AXIS = ( 0. ) + + BODY402_NUT_PREC_RA = ( 0 0 0 0 0 + 3.09217726 + 0.22980637 + 0.06418655 + 0.02533537 + 0.00778695 ) + + + BODY402_NUT_PREC_DEC = ( 0 0 0 0 0 + 1.83936004 + 0.14325320 + 0.01911409 + -0.01482590 + 0.00192430 ) + + + BODY402_NUT_PREC_PM = ( 0 0 0 0 0 + -2.73954829 + -0.39968606 + -0.06563259 + -0.02912940 + 0.01699160 ) + + +\begintext + + +Satellites of Jupiter + + + Io + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY501_POLE_RA = ( 268.05 -0.009 0. ) + BODY501_POLE_DEC = ( 64.50 0.003 0. ) + BODY501_PM = ( 200.39 203.4889538 0. ) + BODY501_LONG_AXIS = ( 0. ) + + BODY501_NUT_PREC_RA = ( 0. 0. 0.094 0.024 ) + BODY501_NUT_PREC_DEC = ( 0. 0. 0.040 0.011 ) + BODY501_NUT_PREC_PM = ( 0. 0. -0.085 -0.022 ) + +\begintext + + + + Europa + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY502_POLE_RA = ( 268.08 -0.009 0. ) + BODY502_POLE_DEC = ( 64.51 0.003 0. ) + BODY502_PM = ( 36.022 101.3747235 0. ) + BODY502_LONG_AXIS = ( 0. ) + + BODY502_NUT_PREC_RA = ( 0. 0. 0. 1.086 0.060 0.015 0.009 ) + BODY502_NUT_PREC_DEC = ( 0. 0. 0. 0.468 0.026 0.007 0.002 ) + BODY502_NUT_PREC_PM = ( 0. 0. 0. -0.980 -0.054 -0.014 -0.008 ) + +\begintext + + + Ganymede + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY503_POLE_RA = ( 268.20 -0.009 0. ) + BODY503_POLE_DEC = ( 64.57 0.003 0. ) + BODY503_PM = ( 44.064 50.3176081 0. ) + BODY503_LONG_AXIS = ( 0. ) + + BODY503_NUT_PREC_RA = ( 0. 0. 0. -0.037 0.431 0.091 ) + BODY503_NUT_PREC_DEC = ( 0. 0. 0. -0.016 0.186 0.039 ) + BODY503_NUT_PREC_PM = ( 0. 0. 0. 0.033 -0.389 -0.082 ) + +\begintext + + + Callisto + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + +\begindata + + BODY504_POLE_RA = ( 268.72 -0.009 0. ) + BODY504_POLE_DEC = ( 64.83 0.003 0. ) + BODY504_PM = ( 259.51 21.5710715 0. ) + BODY504_LONG_AXIS = ( 0. ) + + BODY504_NUT_PREC_RA = ( 0. 0. 0. 0. -0.068 0.590 0. 0.010 ) + BODY504_NUT_PREC_DEC = ( 0. 0. 0. 0. -0.029 0.254 0. -0.004 ) + BODY504_NUT_PREC_PM = ( 0. 0. 0. 0. 0.061 -0.533 0. -0.009 ) + +\begintext + + + Amalthea + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY505_POLE_RA = ( 268.05 -0.009 0. ) + BODY505_POLE_DEC = ( 64.49 0.003 0. ) + BODY505_PM = ( 231.67 722.6314560 0. ) + BODY505_LONG_AXIS = ( 0. ) + + BODY505_NUT_PREC_RA = ( -0.84 0. 0. 0. 0. 0. 0. 0. 0.01 0. ) + BODY505_NUT_PREC_DEC = ( -0.36 0. 0. 0. 0. 0. 0. 0. 0. 0. ) + BODY505_NUT_PREC_PM = ( 0.76 0. 0. 0. 0. 0. 0. 0. -0.01 0. ) + +\begintext + + + Thebe + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY514_POLE_RA = ( 268.05 -0.009 0. ) + BODY514_POLE_DEC = ( 64.49 0.003 0. ) + BODY514_PM = ( 8.56 533.7004100 0. ) + BODY514_LONG_AXIS = ( 0. ) + + BODY514_NUT_PREC_RA = ( 0. -2.11 0. 0. 0. 0. 0. 0. 0. 0.04 ) + BODY514_NUT_PREC_DEC = ( 0. -0.91 0. 0. 0. 0. 0. 0. 0. 0.01 ) + BODY514_NUT_PREC_PM = ( 0. 1.91 0. 0. 0. 0. 0. 0. 0. -0.04 ) + +\begintext + + + Adrastea + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY515_POLE_RA = ( 268.05 -0.009 0. ) + BODY515_POLE_DEC = ( 64.49 0.003 0. ) + BODY515_PM = ( 33.29 1206.9986602 0. ) + BODY515_LONG_AXIS = ( 0. ) + +\begintext + + + Metis + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY516_POLE_RA = ( 268.05 -0.009 0. ) + BODY516_POLE_DEC = ( 64.49 0.003 0. ) + BODY516_PM = ( 346.09 1221.2547301 0. ) + BODY516_LONG_AXIS = ( 0. ) + +\begintext + + + +Satellites of Saturn + + + Mimas + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY601_POLE_RA = ( 40.66 -0.036 0. ) + BODY601_POLE_DEC = ( 83.52 -0.004 0. ) + BODY601_PM = ( 333.46 381.9945550 0. ) + BODY601_LONG_AXIS = ( 0. ) + + BODY601_NUT_PREC_RA = ( 0. 0. 13.56 0. 0. 0. 0. 0. ) + BODY601_NUT_PREC_DEC = ( 0. 0. -1.53 0. 0. 0. 0. 0. ) + BODY601_NUT_PREC_PM = ( 0. 0. -13.48 0. -44.85 0. 0. 0. ) + +\begintext + + + Enceladus + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY602_POLE_RA = ( 40.66 -0.036 0. ) + BODY602_POLE_DEC = ( 83.52 -0.004 0. ) + BODY602_PM = ( 6.32 262.7318996 0. ) + BODY602_LONG_AXIS = ( 0. ) + +\begintext + + + + Tethys + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY603_POLE_RA = ( 40.66 -0.036 0. ) + BODY603_POLE_DEC = ( 83.52 -0.004 0. ) + BODY603_PM = ( 8.95 190.6979085 0. ) + BODY603_LONG_AXIS = ( 0. ) + + BODY603_NUT_PREC_RA = ( 0. 0. 0. 9.66 0. 0. 0. 0. ) + BODY603_NUT_PREC_DEC = ( 0. 0. 0. -1.09 0. 0. 0. 0. ) + BODY603_NUT_PREC_PM = ( 0. 0. 0. -9.60 2.23 0. 0. 0. ) + +\begintext + + + Dione + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY604_POLE_RA = ( 40.66 -0.036 0. ) + BODY604_POLE_DEC = ( 83.52 -0.004 0. ) + BODY604_PM = ( 357.6 131.5349316 0. ) + BODY604_LONG_AXIS = ( 0. ) + +\begintext + + + + Rhea + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY605_POLE_RA = ( 40.38 -0.036 0. ) + BODY605_POLE_DEC = ( 83.55 -0.004 0. ) + BODY605_PM = ( 235.16 79.6900478 0. ) + BODY605_LONG_AXIS = ( 0. ) + + BODY605_NUT_PREC_RA = ( 0. 0. 0. 0. 0. 3.10 0. 0. ) + BODY605_NUT_PREC_DEC = ( 0. 0. 0. 0. 0. -0.35 0. 0. ) + BODY605_NUT_PREC_PM = ( 0. 0. 0. 0. 0. -3.08 0. 0. ) + +\begintext + + + + Titan + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + Note removal of dependence on the nutation precession + angles. + +\begindata + + BODY606_POLE_RA = ( 39.4827 0. 0. ) + BODY606_POLE_DEC = ( 83.4279 0. 0. ) + BODY606_PM = ( 186.5855 22.5769768 0. ) + BODY606_LONG_AXIS = ( 0. ) + + BODY606_NUT_PREC_RA = ( 0. 0. 0. 0. 0. 0. 0. 0 ) + BODY606_NUT_PREC_DEC = ( 0. 0. 0. 0. 0. 0. 0. 0 ) + BODY606_NUT_PREC_PM = ( 0. 0. 0. 0. 0. 0. 0. 0 ) + +\begintext + + + + Hyperion + + The IAU report does not give an orientation model for Hyperion. + Hyperion's rotation is in chaotic and is not predictable for + long periods. + + + Iapetus + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY608_POLE_RA = ( 318.16 -3.949 0. ) + BODY608_POLE_DEC = ( 75.03 -1.143 0. ) + BODY608_PM = ( 355.2 4.5379572 0. ) + BODY608_LONG_AXIS = ( 0. ) + +\begintext + + + + Phoebe + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY609_POLE_RA = ( 356.90 0. 0. ) + BODY609_POLE_DEC = ( 77.80 0. 0. ) + BODY609_PM = ( 178.58 931.639 0. ) + BODY609_LONG_AXIS = ( 0. ) + +\begintext + + + Janus + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY610_POLE_RA = ( 40.58 -0.036 0. ) + BODY610_POLE_DEC = ( 83.52 -0.004 0. ) + BODY610_PM = ( 58.83 518.2359876 0. ) + BODY610_LONG_AXIS = ( 0. ) + + BODY610_NUT_PREC_RA = ( 0. -1.623 0. 0. 0. 0. 0. 0.023 ) + BODY610_NUT_PREC_DEC = ( 0. -0.183 0. 0. 0. 0. 0. 0.001 ) + BODY610_NUT_PREC_PM = ( 0. 1.613 0. 0. 0. 0. 0. -0.023 ) + +\begintext + + + + Epimetheus + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY611_POLE_RA = ( 40.58 -0.036 0. ) + BODY611_POLE_DEC = ( 83.52 -0.004 0. ) + BODY611_PM = ( 293.87 518.4907239 0. ) + BODY611_LONG_AXIS = ( 0. ) + + BODY611_NUT_PREC_RA = ( -3.153 0. 0. 0. 0. 0. 0.086 0. ) + BODY611_NUT_PREC_DEC = ( -0.356 0. 0. 0. 0. 0. 0.005 0. ) + BODY611_NUT_PREC_PM = ( 3.133 0. 0. 0. 0. 0. -0.086 0. ) + +\begintext + + + + Helene + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY612_POLE_RA = ( 40.85 -0.036 0. ) + BODY612_POLE_DEC = ( 83.34 -0.004 0. ) + BODY612_PM = ( 245.12 131.6174056 0. ) + BODY612_LONG_AXIS = ( 0. ) + +\begintext + + + + Telesto + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY613_POLE_RA = ( 50.51 -0.036 0. ) + BODY613_POLE_DEC = ( 84.06 -0.004 0. ) + BODY613_PM = ( 56.88 190.6979332 0. ) + BODY613_LONG_AXIS = ( 0. ) + +\begintext + + + + Calypso + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY614_POLE_RA = ( 36.41 -0.036 0. ) + BODY614_POLE_DEC = ( 85.04 -0.004 0. ) + BODY614_PM = ( 153.51 190.6742373 0. ) + BODY614_LONG_AXIS = ( 0. ) + +\begintext + + + + Atlas + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY615_POLE_RA = ( 40.58 -0.036 0. ) + BODY615_POLE_DEC = ( 83.53 -0.004 0. ) + BODY615_PM = ( 137.88 598.3060000 0. ) + BODY615_LONG_AXIS = ( 0. ) + +\begintext + + + + Prometheus + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY616_POLE_RA = ( 40.58 -0.036 ) + BODY616_POLE_DEC = ( 83.53 -0.004 ) + BODY616_PM = ( 296.14 587.289000 ) + BODY616_LONG_AXIS = ( 0. ) + +\begintext + + + + Pandora + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY617_POLE_RA = ( 40.58 -0.036 0. ) + BODY617_POLE_DEC = ( 83.53 -0.004 0. ) + BODY617_PM = ( 162.92 572.7891000 0. ) + BODY617_LONG_AXIS = ( 0. ) + +\begintext + + + + Pan + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY618_POLE_RA = ( 40.6 -0.036 0. ) + BODY618_POLE_DEC = ( 83.5 -0.004 0. ) + BODY618_PM = ( 48.8 626.0440000 0. ) + BODY618_LONG_AXIS = ( 0. ) + +\begintext + + + + + +Satellites of Uranus + + + + Ariel + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY701_POLE_RA = ( 257.43 0. 0. ) + BODY701_POLE_DEC = ( -15.10 0. 0. ) + BODY701_PM = ( 156.22 -142.8356681 0. ) + BODY701_LONG_AXIS = ( 0. ) + + BODY701_NUT_PREC_RA = ( 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. 0. 0. 0.29 ) + + BODY701_NUT_PREC_DEC = ( 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. 0. 0. 0.28 ) + + BODY701_NUT_PREC_PM = ( 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. 0. 0.05 0.08 ) +\begintext + + + + Umbriel + + Old values: + + Values are unchanged in the 2015 IAU report. + +\begindata + + BODY702_POLE_RA = ( 257.43 0. 0. ) + BODY702_POLE_DEC = ( -15.10 0. 0. ) + BODY702_PM = ( 108.05 -86.8688923 0. ) + BODY702_LONG_AXIS = ( 0. ) + + BODY702_NUT_PREC_RA = ( 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. 0. 0. 0. 0.21 ) + + BODY702_NUT_PREC_DEC = ( 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. 0. 0. 0. 0.20 ) + + BODY702_NUT_PREC_PM = ( 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. 0. -0.09 0. 0.06 ) + +\begintext + + + + Titania + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY703_POLE_RA = ( 257.43 0. 0. ) + BODY703_POLE_DEC = ( -15.10 0. 0. ) + BODY703_PM = ( 77.74 -41.3514316 0. ) + BODY703_LONG_AXIS = ( 0. ) + + BODY703_NUT_PREC_RA = ( 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.29 ) + + BODY703_NUT_PREC_DEC = ( 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.28 ) + + BODY703_NUT_PREC_PM = ( 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.08 ) +\begintext + + + + Oberon + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY704_POLE_RA = ( 257.43 0. 0. ) + BODY704_POLE_DEC = ( -15.10 0. 0. ) + BODY704_PM = ( 6.77 -26.7394932 0. ) + BODY704_LONG_AXIS = ( 0. ) + + + BODY704_NUT_PREC_RA = ( 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. 0.16 ) + + BODY704_NUT_PREC_DEC = ( 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. 0.16 ) + + BODY704_NUT_PREC_PM = ( 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. 0.04 ) +\begintext + + + + Miranda + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY705_POLE_RA = ( 257.43 0. 0. ) + BODY705_POLE_DEC = ( -15.08 0. 0. ) + BODY705_PM = ( 30.70 -254.6906892 0. ) + BODY705_LONG_AXIS = ( 0. ) + + BODY705_NUT_PREC_RA = ( 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 4.41 0. 0. 0. 0. + 0. -0.04 0. ) + + BODY705_NUT_PREC_DEC = ( 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 4.25 0. 0. 0. 0. + 0. -0.02 0. ) + + BODY705_NUT_PREC_PM = ( 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 1.15 -1.27 0. 0. 0. + 0. -0.09 0.15 ) +\begintext + + + + Cordelia + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY706_POLE_RA = ( 257.31 0. 0. ) + BODY706_POLE_DEC = ( -15.18 0. 0. ) + BODY706_PM = ( 127.69 -1074.5205730 0. ) + BODY706_LONG_AXIS = ( 0. ) + + BODY706_NUT_PREC_RA = ( -0.15 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + BODY706_NUT_PREC_DEC = ( 0.14 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + BODY706_NUT_PREC_PM = ( -0.04 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + +\begintext + + + + Ophelia + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY707_POLE_RA = ( 257.31 0. 0. ) + BODY707_POLE_DEC = ( -15.18 0. 0. ) + BODY707_PM = ( 130.35 -956.4068150 0. ) + BODY707_LONG_AXIS = ( 0. ) + + BODY707_NUT_PREC_RA = ( 0. -0.09 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + BODY707_NUT_PREC_DEC = ( 0. 0.09 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + BODY707_NUT_PREC_PM = ( 0. -0.03 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + +\begintext + + + + Bianca + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY708_POLE_RA = ( 257.31 0. 0. ) + BODY708_POLE_DEC = ( -15.18 0. 0. ) + BODY708_PM = ( 105.46 -828.3914760 0. ) + BODY708_LONG_AXIS = ( 0. ) + + BODY708_NUT_PREC_RA = ( 0. 0. -0.16 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + BODY708_NUT_PREC_DEC = ( 0. 0. 0.16 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + BODY708_NUT_PREC_PM = ( 0. 0. -0.04 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + +\begintext + + + + Cressida + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + + BODY709_POLE_RA = ( 257.31 0. 0. ) + BODY709_POLE_DEC = ( -15.18 0. 0. ) + BODY709_PM = ( 59.16 -776.5816320 0. ) + BODY709_LONG_AXIS = ( 0. ) + + + BODY709_NUT_PREC_RA = ( 0. 0. 0. -0.04 0. + 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + + BODY709_NUT_PREC_DEC = ( 0. 0. 0. 0.04 0. + 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + + BODY709_NUT_PREC_PM = ( 0. 0. 0. -0.01 0. + 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + +\begintext + + + + Desdemona + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY710_POLE_RA = ( 257.31 0. 0. ) + BODY710_POLE_DEC = ( -15.18 0. 0. ) + BODY710_PM = ( 95.08 -760.0531690 0. ) + BODY710_LONG_AXIS = ( 0. ) + + BODY710_NUT_PREC_RA = ( 0. 0. 0. 0. -0.17 + 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + BODY710_NUT_PREC_DEC = ( 0. 0. 0. 0. 0.16 + 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + BODY710_NUT_PREC_PM = ( 0. 0. 0. 0. -0.04 + 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + +\begintext + + + + Juliet + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY711_POLE_RA = ( 257.31 0. 0. ) + BODY711_POLE_DEC = ( -15.18 0. 0. ) + BODY711_PM = ( 302.56 -730.1253660 0. ) + BODY711_LONG_AXIS = ( 0. ) + + BODY711_NUT_PREC_RA = ( 0. 0. 0. 0. 0. + -0.06 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + BODY711_NUT_PREC_DEC = ( 0. 0. 0. 0. 0. + 0.06 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + BODY711_NUT_PREC_PM = ( 0. 0. 0. 0. 0. + -0.02 0. 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + +\begintext + + + + Portia + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY712_POLE_RA = ( 257.31 0. 0. ) + BODY712_POLE_DEC = ( -15.18 0. 0. ) + BODY712_PM = ( 25.03 -701.4865870 0. ) + BODY712_LONG_AXIS = ( 0. ) + + BODY712_NUT_PREC_RA = ( 0. 0. 0. 0. 0. + 0. -0.09 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + BODY712_NUT_PREC_DEC = ( 0. 0. 0. 0. 0. + 0. 0.09 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + BODY712_NUT_PREC_PM = ( 0. 0. 0. 0. 0. + 0. -0.02 0. 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + +\begintext + + + + Rosalind + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY713_POLE_RA = ( 257.31 0. 0. ) + BODY713_POLE_DEC = ( -15.18 0. 0. ) + BODY713_PM = ( 314.90 -644.6311260 0. ) + BODY713_LONG_AXIS = ( 0. ) + + BODY713_NUT_PREC_RA = ( 0. 0. 0. 0. 0. + 0. 0. -0.29 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + BODY713_NUT_PREC_DEC = ( 0. 0. 0. 0. 0. + 0. 0. 0.28 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + BODY713_NUT_PREC_PM = ( 0. 0. 0. 0. 0. + 0. 0. -0.08 0. 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + +\begintext + + + + Belinda + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY714_POLE_RA = ( 257.31 0. 0. ) + BODY714_POLE_DEC = ( -15.18 0. 0. ) + BODY714_PM = ( 297.46 -577.3628170 0. ) + BODY714_LONG_AXIS = ( 0. ) + + BODY714_NUT_PREC_RA = ( 0. 0. 0. 0. 0. + 0. 0. 0. -0.03 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + BODY714_NUT_PREC_DEC = ( 0. 0. 0. 0. 0. + 0. 0. 0. 0.03 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + BODY714_NUT_PREC_PM = ( 0. 0. 0. 0. 0. + 0. 0. 0. -0.01 0. + 0. 0. 0. 0. 0. + 0. 0. 0. ) +\begintext + + + + Puck + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY715_POLE_RA = ( 257.31 0. 0. ) + BODY715_POLE_DEC = ( -15.18 0. 0. ) + BODY715_PM = ( 91.24 -472.5450690 0. ) + BODY715_LONG_AXIS = ( 0. ) + + BODY715_NUT_PREC_RA = ( 0. 0. 0. 0. 0. + 0. 0. 0. 0. -0.33 + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + BODY715_NUT_PREC_DEC = ( 0. 0. 0. 0. 0. + 0. 0. 0. 0. 0.31 + 0. 0. 0. 0. 0. + 0. 0. 0. ) + + BODY715_NUT_PREC_PM = ( 0. 0. 0. 0. 0. + 0. 0. 0. 0. -0.09 + 0. 0. 0. 0. 0. + 0. 0. 0. ) + +\begintext + + + + +Satellites of Neptune + + + Triton + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY801_POLE_RA = ( 299.36 0. 0. ) + BODY801_POLE_DEC = ( 41.17 0. 0. ) + BODY801_PM = ( 296.53 -61.2572637 0. ) + BODY801_LONG_AXIS = ( 0. ) + + + BODY801_NUT_PREC_RA = ( 0. 0. 0. 0. + 0. 0. 0. -32.35 + 0. -6.28 -2.08 -0.74 + -0.28 -0.11 -0.07 -0.02 + -0.01 ) + + + BODY801_NUT_PREC_DEC = ( 0. 0. 0. 0. + 0. 0. 0. 22.55 + 0. 2.10 0.55 0.16 + 0.05 0.02 0.01 0. + 0. ) + + + BODY801_NUT_PREC_PM = ( 0. 0. 0. 0. + 0. 0. 0. 22.25 + 0. 6.73 2.05 0.74 + 0.28 0.11 0.05 0.02 + 0.01 ) + +\begintext + + + + + Nereid + + Old values: + + The 2009 IAU report [3] states that values for Nereid are not + given because Nereid is not in synchronous rotation with Neptune + (notes following table 2). + + Current values: + + The 2015 IAU report does not provide values for Nereid. + + Naiad + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY803_POLE_RA = ( 299.36 0. 0. ) + BODY803_POLE_DEC = ( 43.36 0. 0. ) + BODY803_PM = ( 254.06 +1222.8441209 0. ) + BODY803_LONG_AXIS = ( 0. ) + + + BODY803_NUT_PREC_RA = ( 0.70 -6.49 0. 0. + 0. 0. 0. 0. + 0.25 0. 0. 0. + 0. 0. 0. 0. + 0. ) + + BODY803_NUT_PREC_DEC = ( -0.51 -4.75 0. 0. + 0. 0. 0. 0. + 0.09 0. 0. 0. + 0. 0. 0. 0. + 0. ) + + BODY803_NUT_PREC_PM = ( -0.48 4.40 0. 0. + 0. 0. 0. 0. + -0.27 0. 0. 0. + 0. 0. 0. 0. + 0. ) + +\begintext + + + Thalassa + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY804_POLE_RA = ( 299.36 0. 0. ) + BODY804_POLE_DEC = ( 43.45 0. 0. ) + BODY804_PM = ( 102.06 1155.7555612 0. ) + BODY804_LONG_AXIS = ( 0. ) + + + BODY804_NUT_PREC_RA = ( 0.70 0. -0.28 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. ) + + + BODY804_NUT_PREC_DEC = ( -0.51 0. -0.21 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. ) + + BODY804_NUT_PREC_PM = ( -0.48 0. 0.19 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. ) + +\begintext + + + Despina + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY805_POLE_RA = ( 299.36 0. 0. ) + BODY805_POLE_DEC = ( 43.45 0. 0. ) + BODY805_PM = ( 306.51 +1075.7341562 0. ) + BODY805_LONG_AXIS = ( 0. ) + + + BODY805_NUT_PREC_RA = ( 0.70 0. 0. -0.09 + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. ) + + BODY805_NUT_PREC_DEC = ( -0.51 0. 0. -0.07 + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. ) + + BODY805_NUT_PREC_PM = ( -0.49 0. 0. 0.06 + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. ) +\begintext + + + + Galatea + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + +\begindata + + BODY806_POLE_RA = ( 299.36 0. 0. ) + BODY806_POLE_DEC = ( 43.43 0. 0. ) + BODY806_PM = ( 258.09 839.6597686 0. ) + BODY806_LONG_AXIS = ( 0. ) + + + BODY806_NUT_PREC_RA = ( 0.70 0. 0. 0. + -0.07 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. ) + + BODY806_NUT_PREC_DEC = ( -0.51 0. 0. 0. + -0.05 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. ) + + BODY806_NUT_PREC_PM = ( -0.48 0. 0. 0. + 0.05 0. 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. ) +\begintext + + + Larissa + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY807_POLE_RA = ( 299.36 0. 0. ) + BODY807_POLE_DEC = ( 43.41 0. 0. ) + BODY807_PM = ( 179.41 +649.0534470 0. ) + BODY807_LONG_AXIS = ( 0. ) + + + BODY807_NUT_PREC_RA = ( 0.70 0. 0. 0. + 0. -0.27 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. ) + + BODY807_NUT_PREC_DEC = ( -0.51 0. 0. 0. + 0. -0.20 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. ) + + BODY807_NUT_PREC_PM = ( -0.48 0. 0. 0. + 0. 0.19 0. 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. ) +\begintext + + + + Proteus + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY808_POLE_RA = ( 299.27 0. 0. ) + BODY808_POLE_DEC = ( 42.91 0. 0. ) + BODY808_PM = ( 93.38 +320.7654228 0. ) + BODY808_LONG_AXIS = ( 0. ) + + + BODY808_NUT_PREC_RA = ( 0.70 0. 0. 0. + 0. 0. -0.05 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. ) + + BODY808_NUT_PREC_DEC = ( -0.51 0. 0. 0. + 0. 0. -0.04 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. ) + + BODY808_NUT_PREC_PM = ( -0.48 0. 0. 0. + 0. 0. 0.04 0. + 0. 0. 0. 0. + 0. 0. 0. 0. + 0. ) + +\begintext + + + + + +Satellites of Pluto + + Charon + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY901_POLE_RA = ( 132.993 0. 0. ) + BODY901_POLE_DEC = ( -6.163 0. 0. ) + BODY901_PM = ( 122.695 56.3625225 0. ) + BODY901_LONG_AXIS = ( 0. ) + +\begintext + + + +Orientation constants for Selected Comets and Asteroids +-------------------------------------------------------- + + + +Ceres + + Old values are from the 2009 IAU report. + + body2000001_pole_ra = ( 291. 0. 0. ) + body2000001_pole_dec = ( 59. 0. 0. ) + body2000001_pm = ( 170.90 952.1532 0. ) + body2000001_long_axis = ( 0. ) + + + Current values: + +\begindata + + BODY2000001_POLE_RA = ( 291.418 0. 0. ) + BODY2000001_POLE_DEC = ( 66.764 0. 0. ) + BODY2000001_PM = ( 170.650 952.1532 0. ) + BODY2000001_LONG_AXIS = ( 0. ) + +\begintext + + + +Pallas + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY2000002_POLE_RA = ( 33. 0. 0. ) + BODY2000002_POLE_DEC = ( -3. 0. 0. ) + BODY2000002_PM = ( 38. 1105.8036 0. ) + BODY2000002_LONG_AXIS = ( 0. ) + +\begintext + + + +Vesta + + Old values: + + Values are from the 2009 IAU report. + + body2000004_pole_ra = ( 305.8 0. 0. ) + body2000004_pole_dec = ( 41.4 0. 0. ) + body2000004_pm = ( 292. 1617.332776 0. ) + body2000004_long_axis = ( 0. ) + + Current values: + +\begindata + + BODY2000004_POLE_RA = ( 309.031 0. 0. ) + BODY2000004_POLE_DEC = ( 42.235 0. 0. ) + BODY2000004_PM = ( 285.39 1617.3329428 0. ) + BODY2000004_LONG_AXIS = ( 0. ) + +\begintext + + + +52 Europa (asteroid) + + + Current values: + + Values are provided for the first time in the 2015 IAU report. + +\begindata + + BODY2000052_POLE_RA = ( 257.0 0. 0. ) + BODY2000052_POLE_DEC = ( 12.0 0. 0. ) + BODY2000052_PM = ( 55.0 1534.6472187 0. ) + BODY2000052_LONG_AXIS = ( 0. ) + +\begintext + + + +Lutetia + + Old values: + + Values are from the 2009 IAU report. + + Current values: + +\begindata + + BODY2000021_POLE_RA = ( 52. 0. 0. ) + BODY2000021_POLE_DEC = ( 12. 0. 0. ) + BODY2000021_PM = ( 94. 1057.7515 0. ) + BODY2000021_LONG_AXIS = ( 0. ) + +\begintext + + + +Ida + + Old values are from the 2009 IAU report. + + body2431010_pole_ra = ( 168.76 0. 0. ) + body2431010_pole_dec = ( -2.88 0. 0. ) + body2431010_pm = ( 274.05 +1864.6280070 0. ) + body2431010_long_axis = ( 0. ) + + The PM constant W0 is from [4]. + + + Current values: + + +\begindata + + BODY2431010_POLE_RA = ( 168.76 0. 0. ) + BODY2431010_POLE_DEC = ( -87.12 0. 0. ) + BODY2431010_PM = ( 274.05 +1864.6280070 0. ) + BODY2431010_LONG_AXIS = ( 0. ) + +\begintext + + + +Eros + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY2000433_POLE_RA = ( 11.35 0. 0. ) + BODY2000433_POLE_DEC = ( 17.22 0. 0. ) + BODY2000433_PM = ( 326.07 1639.38864745 0. ) + BODY2000433_LONG_AXIS = ( 0. ) + +\begintext + + + +Davida + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY2000511_POLE_RA = ( 297. 0. 0. ) + BODY2000511_POLE_DEC = ( 5. 0. 0. ) + BODY2000511_PM = ( 268.1 1684.4193549 0. ) + BODY2000511_LONG_AXIS = ( 0. ) + +\begintext + + + +Gaspra + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY9511010_POLE_RA = ( 9.47 0. 0. ) + BODY9511010_POLE_DEC = ( 26.70 0. 0. ) + BODY9511010_PM = ( 83.67 1226.9114850 0. ) + BODY9511010_LONG_AXIS = ( 0. ) + +\begintext + + + +Steins + + Old values are from the 2009 IAU report. + + body2002867_pole_ra = ( 90. 0. 0. ) + body2002867_pole_dec = ( -62. 0. 0. ) + body2002867_pm = ( 93.94 1428.852332 0. ) + body2002867_long_axis = ( 0. ) + + Current values: + +\begindata + + BODY2002867_POLE_RA = ( 91. 0. 0. ) + BODY2002867_POLE_DEC = ( -62. 0. 0. ) + BODY2002867_PM = ( 321.76 1428.09917 0. ) + BODY2002867_LONG_AXIS = ( 0. ) + +\begintext + + + +Itokawa + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY2025143_POLE_RA = ( 90.53 0. 0. ) + BODY2025143_POLE_DEC = ( -66.30 0. 0. ) + BODY2025143_PM = ( 000.0 712.143 0. ) + BODY2025143_LONG_AXIS = ( 0. ) + +\begintext + + + +9P/Tempel 1 + + + Old values are from the 2009 IAU report. + + body1000093_pole_ra = ( 294. 0. 0. ) + body1000093_pole_dec = ( 73. 0. 0. ) + body1000093_pm = ( 252.63 212.064 0. ) + body1000093_long_axis = ( 0. ) + + Current values: + + Values are from the 2015 IAU report [1]. + + Two sets of prime meridian values are given in [1]: one + for the epoch of the Deep Impact mission's impactor's + collision with the comet, and one for the epoch of the + Stardust NExT closest approach. + + Deep Impact: + + Epoch: 2005-07-04 05:45:38.4 TDB + 2453555.740027 JD TDB + + . 2 2 2 + W = 109.7, W = 211.849 deg/day, d W/dt = 0.024 deg/day + + Stardust NExT: + + Epoch: 2011-02-15 04:40:18.6 TDB + 2455607.694660 JD TDB + + . + W = 69.2, W = 212.807 deg/day + + The values of W shown above are the prime meridian angles at + the respective epochs. + + Prime meridian data below are those associated with the epoch of the + Stardust NExT closest approach. + + Pole direction data are the same for both epochs. + +\begindata + + BODY1000093_POLE_RA = ( 255. 0. 0. ) + BODY1000093_POLE_DEC = ( 64.5 0. 0. ) + BODY1000093_PM = ( 69.2 212.807 0. ) + BODY1000093_LONG_AXIS = ( 0. ) + + BODY1000093_CONSTANTS_JED_EPOCH = 2455607.694660 + +\begintext + + + +19P/Borrelly + + Old values: + + body1000005_pole_ra = ( 218.5 0. 0. ) + body1000005_pole_dec = ( -12.5 0. 0. ) + body1000005_pm = ( 000. 390.0 0. ) + body1000005_long_axis = ( 0. ) + + Current values: + + The 2015 IAU report does not cite a value for W0, so a + complete orientation model based on that source is not + available. Data are provided here for backward compatibility + with pck00010.tpc. + + The W0 value was set to zero in that file and so is + zero here. + +\begindata + + BODY1000005_POLE_RA = ( 218.5 0. 0. ) + BODY1000005_POLE_DEC = ( -12.5 0. 0. ) + BODY1000005_PM = ( 000. 324.3 0. ) + BODY1000005_LONG_AXIS = ( 0. ) + +\begintext + + + +67P/Churyumov-Gerasimenko + + + Current values: + + Values are provided for the first time in the 2015 IAU report. + + The time range associated with the rotation model is + + 2014 MAR 3 : 2014 SEP 3 + + The reference epoch of the rotational elements is J2000. + +\begindata + + BODY1000012_POLE_RA = ( 69.54 0. 0. ) + BODY1000012_POLE_DEC = ( 64.11 0. 0. ) + BODY1000012_PM = ( 114.69 696.543884683 0. ) + BODY1000012_LONG_AXIS = ( 0. ) + +\begintext + + + +103P/Hartley 2 + + + Current values: + + Values are provided for the first time in the 2015 IAU report. + + The 2015 IAU report provides only right ascension and + declination values for body axes at the epoch of the EPOXI + closest approach. The Z-axis is the long axis. The report + uses the symbols alpha and delta to denote right ascension + and declination respectively. + + Epoch: 2010-11-04 14:00:53.9 TDB + JD 2455505.083957 TDB + + + alpha = 285.1 deg. delta = -31.8 deg. + X X + + alpha = 350.4 deg. delta = 34.4 deg. + Y Y + + alpha = 226.1 deg. delta = 39.4 deg. + Z Z + + + + +Radii of Sun and Planets +-------------------------------------------------------- + + +Sun + + Old values: + + Values are from the 2009 IAU report. + + body10_radii = ( 696000. 696000. 696000. ) + + +\begindata + + BODY10_RADII = ( 695700. 695700. 695700. ) + +\begintext + + +Mercury + + Old values: + + Values are from the 2009 IAU report. + + body199_radii = ( 2439.7 2439.7 2439.7 ) + + + Current values: + +\begindata + + BODY199_RADII = ( 2440.53 2440.53 2438.26 ) + +\begintext + + +Venus + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY299_RADII = ( 6051.8 6051.8 6051.8 ) + +\begintext + + +Earth + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY399_RADII = ( 6378.1366 6378.1366 6356.7519 ) + +\begintext + + +Mars + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + The 2015 IAU report gives separate values for the north and + south polar radii: + + north: 3373.19 + south: 3379.21 + + The report provides the average of these values as well, + which we use as the polar radius for the triaxial model. + +\begindata + + BODY499_RADII = ( 3396.19 3396.19 3376.20 ) + +\begintext + + + +Jupiter + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY599_RADII = ( 71492 71492 66854 ) + +\begintext + + + +Saturn + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY699_RADII = ( 60268 60268 54364 ) + +\begintext + + + +Uranus + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY799_RADII = ( 25559 25559 24973 ) + +\begintext + + + +Neptune + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + (Values are for the 1 bar pressure level.) + +\begindata + + BODY899_RADII = ( 24764 24764 24341 ) + +\begintext + + + +Radii of the Dwarf Planet Pluto +-------------------------------------------------------- + + +Pluto + + Old values: + + Values are from the 2009 IAU report. + + body999_radii = ( 1195 1195 1195 ) + + Current values: + +\begindata + + BODY999_RADII = ( 1188.3 1188.3 1188.3 ) + +\begintext + + + + +Radii of Satellites +-------------------------------------------------------- + + +Moon + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY301_RADII = ( 1737.4 1737.4 1737.4 ) + +\begintext + + + +Satellites of Mars + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY401_RADII = ( 13.0 11.4 9.1 ) + BODY402_RADII = ( 7.8 6.0 5.1 ) + +\begintext + + + +Satellites of Jupiter + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + Note that for Ganymede and Callisto only mean radii + are provided. + +\begindata + + BODY501_RADII = ( 1829.4 1819.4 1815.7 ) + BODY502_RADII = ( 1562.6 1560.3 1559.5 ) + BODY503_RADII = ( 2631.2 2631.2 2631.2 ) + BODY504_RADII = ( 2410.3 2410.3 2410.3 ) + BODY505_RADII = ( 125 73 64 ) + +\begintext + + Only mean radii are available in the 2015 IAU report for bodies + 506-513. + +\begindata + + BODY506_RADII = ( 85 85 85 ) + BODY507_RADII = ( 40 40 40 ) + BODY508_RADII = ( 18 18 18 ) + BODY509_RADII = ( 14 14 14 ) + BODY510_RADII = ( 12 12 12 ) + BODY511_RADII = ( 15 15 15 ) + BODY512_RADII = ( 10 10 10 ) + BODY513_RADII = ( 5 5 5 ) + BODY514_RADII = ( 58 49 42 ) + BODY515_RADII = ( 10 8 7 ) + BODY516_RADII = ( 30 20 17 ) + +\begintext + + + +Satellites of Saturn + + + Old values: + + Values are from the 2009 IAU report. + + + body601_radii = ( 207.8 196.7 190.6 ) + body602_radii = ( 256.6 251.4 248.3 ) + body603_radii = ( 538.4 528.3 526.3 ) + body604_radii = ( 563.4 561.3 559.6 ) + body605_radii = ( 765.0 763.1 762.4 ) + body606_radii = ( 2575.15 2574.78 2574.47 ) + body607_radii = ( 180.1 133.0 102.7 ) + body608_radii = ( 745.7 745.7 712.1 ) + body609_radii = ( 109.4 108.5 101.8 ) + body610_radii = ( 101.5 92.5 76.3 ) + body611_radii = ( 64.9 57.0 53.1 ) + body612_radii = ( 21.7 19.1 13.0 ) + body613_radii = ( 16.3 11.8 10.0 ) + body614_radii = ( 15.1 11.5 7.0 ) + body615_radii = ( 20.4 17.7 9.4 ) + body616_radii = ( 67.8 39.7 29.7 ) + body617_radii = ( 52.0 40.5 32.0 ) + body618_radii = ( 17.2 15.7 10.4 ) + body632_radii = ( 1.6 1.6 1.6 ) + body633_radii = ( 2.9 2.8 2.0 ) + body634_radii = ( 1.5 1.2 1.0 ) + body635_radii = ( 4.3 4.1 3.2 ) + body649_radii = ( 1 1 1 ) + + + Current values: + +\begindata + + BODY601_RADII = ( 207.8 196.7 190.6 ) + BODY602_RADII = ( 256.6 251.4 248.3 ) + BODY603_RADII = ( 538.4 528.3 526.3 ) + BODY604_RADII = ( 563.4 561.3 559.6 ) + BODY605_RADII = ( 765.0 763.1 762.4 ) + BODY606_RADII = ( 2575.15 2574.78 2574.47 ) + BODY607_RADII = ( 180.1 133.0 102.7 ) + BODY608_RADII = ( 745.7 745.7 712.1 ) + BODY609_RADII = ( 109.4 108.5 101.8 ) + BODY610_RADII = ( 101.7 93.0 76.3 ) + BODY611_RADII = ( 64.9 57.3 53.0 ) + BODY612_RADII = ( 22.5 19.6 13.3 ) + BODY613_RADII = ( 16.3 11.8 9.8 ) + BODY614_RADII = ( 15.3 9.3 6.3 ) + BODY615_RADII = ( 20.5 17.8 9.4 ) + BODY616_RADII = ( 68.2 41.6 28.2 ) + BODY617_RADII = ( 52.2 40.8 31.5 ) + BODY618_RADII = ( 17.2 15.4 10.4 ) + BODY632_RADII = ( 1.94 1.29 1.21 ) + BODY633_RADII = ( 2.88 2.08 1.8 ) + BODY634_RADII = ( 1.5 1.2 1.0 ) + BODY635_RADII = ( 4.6 4.5 2.8 ) + BODY649_RADII = ( 0.5 0.5 0.5 ) + BODY653_RADII = ( 0.7 0.25 0.2 ) + +\begintext + + + +Satellites of Uranus + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY701_RADII = ( 581.1 577.9 577.7 ) + BODY702_RADII = ( 584.7 584.7 584.7 ) + BODY703_RADII = ( 788.9 788.9 788.9 ) + BODY704_RADII = ( 761.4 761.4 761.4 ) + BODY705_RADII = ( 240.4 234.2 232.9 ) + +\begintext + + The 2015 IAU report gives only mean radii for satellites 706--715. + +\begindata + + BODY706_RADII = ( 13 13 13 ) + BODY707_RADII = ( 15 15 15 ) + BODY708_RADII = ( 21 21 21 ) + BODY709_RADII = ( 31 31 31 ) + BODY710_RADII = ( 27 27 27 ) + BODY711_RADII = ( 42 42 42 ) + BODY712_RADII = ( 54 54 54 ) + BODY713_RADII = ( 27 27 27 ) + BODY714_RADII = ( 33 33 33 ) + BODY715_RADII = ( 77 77 77 ) + +\begintext + + + + +Satellites of Neptune + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + The 2015 IAU report gives mean radii only for bodies 801-806. + +\begindata + + BODY801_RADII = ( 1352.6 1352.6 1352.6 ) + BODY802_RADII = ( 170 170 170 ) + BODY803_RADII = ( 29 29 29 ) + BODY804_RADII = ( 40 40 40 ) + BODY805_RADII = ( 74 74 74 ) + BODY806_RADII = ( 79 79 79 ) + +\begintext + + The second equatorial radius for Larissa is not given in the 2009 + report. The available values are: + + BODY807_RADII = ( 104 --- 89 ) + + For use within the SPICE system, we use only the mean radius. + +\begindata + + BODY807_RADII = ( 96 96 96 ) + BODY808_RADII = ( 218 208 201 ) + +\begintext + + + + +Satellites of Pluto + + + Old values: + + Values are from the 2009 IAU report. + + BODY901_RADII = ( 605 605 605 ) + + Current values: + +\begindata + + BODY901_RADII = ( 606 606 606 ) + +\begintext + + + +Radii for Selected Comets and Asteroids +-------------------------------------------------------- + + +Ceres + + Old values: + + Values are from the 2009 IAU report. + + body2000001_radii = ( 487.3 487.3 454.7 ) + + Current values: + + +\begindata + + BODY2000001_RADII = ( 487.3 487.3 446. ) + +\begintext + + + +Vesta + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + +\begindata + + BODY2000004_RADII = ( 289. 280. 229. ) + +\begintext + + + +Psyche + + Current values: + + Values are provided for the first time in the 2015 IAU report. + + +\begindata + + BODY2000016_RADII = ( 139.5 116. 94.5 ) + +\begintext + + + +Lutetia + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + +\begindata + + BODY2000021_RADII = ( 62.0 50.5 46.5 ) + +\begintext + + + +52 Europa + + + Current values: + + Values are provided for the first time in the 2015 IAU report. + + +\begindata + + BODY2000052_RADII = ( 189.5 165. 124.5 ) + +\begintext + +Ida + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + +\begindata + + BODY2431010_RADII = ( 26.8 12.0 7.6 ) + +\begintext + + + +Mathilde + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + +\begindata + + BODY2000253_RADII = ( 33. 24. 23. ) + +\begintext + + + +Eros + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + +\begindata + + BODY2000433_RADII = ( 17.0 5.5 5.5 ) + +\begintext + + + +Davida + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + +\begindata + + BODY2000511_RADII = ( 180. 147. 127. ) + +\begintext + + + +Gaspra + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + +\begindata + + BODY9511010_RADII = ( 9.1 5.2 4.4 ) + +\begintext + + + +Steins + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + +\begindata + + BODY2002867_RADII = ( 3.24 2.73 2.04 ) + +\begintext + + + +Toutatis + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + +\begindata + + BODY2004179_RADII = ( 2.13 1.015 0.85 ) + +\begintext + + + +Itokawa + + + Old values: + + Values are from the 2009 IAU report. Note that the + diameters rather than radii were given. + + body2025143_radii = ( 0.535 0.294 0.209 ) + + Current values: + + +\begindata + + BODY2025143_RADII = ( 0.268 0.147 0.104 ) + +\begintext + + +Kleopatra + + + Old values: + + Values are from the 2003 report [13]. + + A shape model was not provided in later reports because, + according to [5], the shape had been "modeled from + low resolution radar data, and cannot be mapped from those + data." + + body2000216_radii = ( 108.5 47 40.5 ) + + + Current values: + + + No values are provided in the 2015 IAU report. + + + +Halley + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + +\begindata + + BODY1000036_RADII = ( 8.0 4.0 4.0 ) + +\begintext + + + +9P/Tempel 1 + + + Old values: + + The effective radius is unchanged in the 2009 IAU report. + + Current values: + + According to [1]: + + The maximum and minimum radii are not properly + the values of the principal semi-axes, they + are half the maximum and minimum values of the + diameter. Due to the large deviations from a + simple ellipsoid, they may not correspond with + measurements along the principal axes, or be + orthogonal to each other. + + The radii along the first and second principal axes + are given as + + 3.7 km + 2.5 km + + The value in the data assignment below is the mean radius. + +\begindata + + BODY1000093_RADII = ( 3.0 3.0 3.0 ) + +\begintext + + +19P/Borrelly + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + The first principal axis length is + + 3.5 km + + The lengths of the other semi-axes are not provided + by [1]. + + The value in the data assignment below is the mean radius. + +\begindata + + BODY1000005_RADII = ( 4.22 4.22 4.22 ) + +\begintext + + + +81P/Wild 2 + + + Old values: + + Values are unchanged in the 2015 IAU report. + + Current values: + + +\begindata + + BODY1000107_RADII = ( 2.7 1.9 1.5 ) + +\begintext + + + +67P/Churyumov-Gerasimenko + + Current values: + + Values are provided for the first time in the 2015 IAU report. + +\begindata + + BODY1000012_RADII = ( 2.40 1.55 1.20 ) + +\begintext + + + +103P/Hartley 2 + + The most recent "Report of the IAU Working Group on Cartographic + Coordinates and Rotational Elements: 2015" appears to incorrectly list + the radii for Comet 103P/Hartley 2 in Table 6. The following text by + Brent Archinal, Chair of the Working Group, examines this problem and + what radii should likely be used. + + However, note that this explanation has not yet been officially + considered and the proposed changes recommended by the Working Group. + Such a process will begin shortly, and a consensus document about any + changes may be published on the Working Group website. + + Clearly from the many figures in various papers (e.g. A'Hearn et al, + 2011, Science, 332, 1396; Belton, et al., 2012 Icarus, 222, 595; + Thomas, et al. 2013, Icarus, 222, 550), Comet 103P/Hartley 2 has an + elongated nucleus, with the long axis being the (reference) spin axis. + This is stated/shown e.g., in Figure 3 of the A'Hearn et al. paper. + The size is stated in a few places as having a diameter of 0.69 to + 2.33 km and a mean radius of 0.58 +/-0.02 km (A'Hearn, et al., + Table 1; Thomas et al., Table 1 (but now with a mean radius uncertainty + of 0.018 km)). This of course translates to a mean radius of 0.58 km, + a minimum radius of 0.345 km (or rounding, 0.34 km), and a maximum + radius of 1.165 km (rounding, 1.16 km). I don't really see a clear + statement in these papers that these last two numbers can be used for + the semi axes, just that they are minimum and maximum values. + Apparently though that's been assumed (as it has been for some of the + other comets listed in the WG report). There is also no clear statement + of what if any difference there is between the first and second semi + axis, but only that they are "similar". E.g., Thomas et al. says + (Section 3) "This bi-lobed object has near rotational symmetry". + That does correspond to what's said in footnote (g) of the WG report. + + So, I think it is correct that: + + mean radius = 0.58 km + a semi-axis = 0.34 km + b semi-axis = 0.34 km (or "~0.34 km") + c semi-axis (polar axis) = 1.16 km + + Due to their uncertain status, these data are included in this file + only as comments. To enable SPICE software to access the data, + move this assignment + + BODY1000041_RADII = ( 0.34 0.34 1.16 ) + + below the \begindata marker below. + +\begindata + + +\begintext + +=========================================================================== +End of file pck00011_n0066.tpc +=========================================================================== diff --git a/tools/lox-gen/Cargo.lock b/tools/lox-gen/Cargo.lock index 079b1ec4..fd2de7f5 100644 --- a/tools/lox-gen/Cargo.lock +++ b/tools/lox-gen/Cargo.lock @@ -1,6 +1,6 @@ # This file is automatically @generated by Cargo. # It is not intended for manual editing. -version = 3 +version = 4 [[package]] name = "aho-corasick" @@ -91,9 +91,9 @@ dependencies = [ [[package]] name = "fast_polynomial" -version = "0.1.0" +version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "831e16abe0108eef0005da4a921664c9c15707301148c30ecfc5c9ae4b3fdeda" +checksum = "62eea6ee590b08a5f8b1139f4d6caee195b646d0c07e4b1808fbd5c4dea4829a" dependencies = [ "num-traits", ] @@ -106,9 +106,9 @@ checksum = "28a80e3145d8ad11ba0995949bbcf48b9df2be62772b3d351ef017dff6ecb853" [[package]] name = "glam" -version = "0.28.0" +version = "0.29.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "779ae4bf7e8421cf91c0b3b64e7e8b40b862fba4d393f59150042de7c4965a94" +checksum = "dc46dd3ec48fdd8e693a98d2b8bafae273a2d54c1de02a2a7e3d57d501f39677" [[package]] name = "iana-time-zone" @@ -148,12 +148,6 @@ dependencies = [ "wasm-bindgen", ] -[[package]] -name = "lazy_static" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" - [[package]] name = "libc" version = "0.2.155" @@ -179,11 +173,11 @@ dependencies = [ name = "lox-gen" version = "0.1.0" dependencies = [ - "lazy_static", "lox-io", + "prettyplease", "proc-macro2", "quote", - "thiserror", + "syn", ] [[package]] @@ -249,11 +243,21 @@ version = "1.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" +[[package]] +name = "prettyplease" +version = "0.2.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64d1ec885c64d0457d564db4ec299b2dae3f9c02808b8ad9c3a089c591b18033" +dependencies = [ + "proc-macro2", + "syn", +] + [[package]] name = "proc-macro2" -version = "1.0.86" +version = "1.0.92" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77" +checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0" dependencies = [ "unicode-ident", ] @@ -270,9 +274,9 @@ dependencies = [ [[package]] name = "quote" -version = "1.0.36" +version = "1.0.37" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7" +checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af" dependencies = [ "proc-macro2", ] @@ -356,9 +360,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.68" +version = "2.0.90" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "901fa70d88b9d6c98022e23b4136f9f3e54e4662c3bc1bd1d84a42a9a0f0c1e9" +checksum = "919d3b74a5dd0ccd15aeb8f93e7006bd9e14c295087c9896a110f490752bcf31" dependencies = [ "proc-macro2", "quote", @@ -367,18 +371,18 @@ dependencies = [ [[package]] name = "thiserror" -version = "1.0.61" +version = "2.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709" +checksum = "2f49a1853cf82743e3b7950f77e0f4d622ca36cf4317cba00c767838bac8d490" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.61" +version = "2.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533" +checksum = "8381894bb3efe0c4acac3ded651301ceee58a15d47c2e34885ed1908ad667061" dependencies = [ "proc-macro2", "quote", diff --git a/tools/lox-gen/Cargo.toml b/tools/lox-gen/Cargo.toml index d5fc1ab6..0ff6e2d9 100644 --- a/tools/lox-gen/Cargo.toml +++ b/tools/lox-gen/Cargo.toml @@ -7,7 +7,7 @@ publish = false [dependencies] lox-io = { path = "../../crates/lox-io" } -lazy_static = "1.4.0" -proc-macro2 = "1.0.78" -quote = "1.0.35" -thiserror = "1.0.57" +proc-macro2 = "1.0.92" +quote = "1.0.37" +syn = "2.0.90" +prettyplease = "0.2.25" diff --git a/tools/lox-gen/src/bodies.rs b/tools/lox-gen/src/bodies.rs deleted file mode 100644 index 8d2d682d..00000000 --- a/tools/lox-gen/src/bodies.rs +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright (c) 2023. 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/. - */ - -use proc_macro2::Ident; -use quote::format_ident; - -pub struct BodyDef { - pub name: &'static str, - pub id: i32, - pub body_trait: Option<&'static str>, -} - -impl BodyDef { - pub fn ident(&self) -> Ident { - format_ident!("{}", self.name.replace([' ', '-'], "")) - } - - pub fn body_trait(&self) -> Option { - self.body_trait - .map(|body_trait| format_ident!("{}", body_trait)) - } -} diff --git a/tools/lox-gen/src/common.rs b/tools/lox-gen/src/common.rs index 608985a5..537698ae 100644 --- a/tools/lox-gen/src/common.rs +++ b/tools/lox-gen/src/common.rs @@ -1,3 +1,7 @@ +use proc_macro2::TokenStream; +use std::fs; +use std::path::Path; + pub const COPYRIGHT_NOTICE: &str = "/* * Copyright (c) 2024. Helge Eichhorn and the LOX contributors * @@ -7,3 +11,17 @@ pub const COPYRIGHT_NOTICE: &str = "/* */\n\n"; pub const AUTO_GENERATION_NOTICE: &str = "// Auto-generated by `lox-gen`. Do not edit!\n\n"; + +pub fn format(ts: TokenStream) -> String { + let file = syn::parse2(ts).unwrap(); + prettyplease::unparse(&file) +} + +pub fn write_file(dir: &Path, file: &str, code: TokenStream) { + let mut module = String::from(COPYRIGHT_NOTICE); + module.push_str(AUTO_GENERATION_NOTICE); + module.push_str(&format(code)); + + let out = dir.join(file); + fs::write(&out, module).expect("file should be writeable"); +} diff --git a/tools/lox-gen/src/frames.rs b/tools/lox-gen/src/frames.rs deleted file mode 100644 index ddf7bdaa..00000000 --- a/tools/lox-gen/src/frames.rs +++ /dev/null @@ -1,1314 +0,0 @@ -use std::{fs, path::Path, process::Command}; - -use proc_macro2::{Ident, TokenStream}; -use quote::{format_ident, quote}; - -use crate::common::{AUTO_GENERATION_NOTICE, COPYRIGHT_NOTICE}; - -pub struct Frame { - pub ident: &'static str, - pub name: &'static str, - pub abbreviation: &'static str, - pub is_bodyfixed: bool, -} - -impl Frame { - pub fn ident(&self) -> Ident { - format_ident!("{}", self.ident) - } -} - -fn generate_transform(target: &Frame, frames: &[Frame], code: &mut TokenStream) { - let target_ident = target.ident(); - - let target_type = if target.is_bodyfixed { - quote!(BodyFixed<#target_ident>) - } else { - quote!(#target_ident) - }; - - let mut match_arms = quote! {}; - - if target.ident == "Icrf" { - frames.iter().for_each(|f| { - let ident = f.ident(); - - let f_value = if f.is_bodyfixed { - quote!(BodyFixed(#ident)) - } else { - quote!(#ident) - }; - - match_arms.extend(if target.ident == f.ident { - quote! { - PyFrame::#ident => Ok(self.0.with_frame(frame)), - } - } else { - quote! { - PyFrame::#ident => self.0.with_frame(#f_value).try_to_frame(frame, provider), - } - }); - }); - } else { - match_arms.extend(quote! { - PyFrame::Icrf => self.0.with_frame(Icrf).try_to_frame(frame, provider), - PyFrame::#target_ident => Ok(self.0.with_frame(frame)), - _ => self - .try_to_frame(Icrf, provider)? - .try_to_frame(frame, provider), - }); - } - - code.extend(quote! { - impl TryToFrame<#target_type, T> for PyState - where - T: FrameTransformationProvider + PyDeltaUt1Provider, - { - type Output = State; - type Error = T::Error; - - fn try_to_frame( - &self, - frame: #target_type, - provider: &T, - ) -> Result, T::Error> { - match self.0.reference_frame() { - #match_arms - } - } - } - }) -} - -pub fn generate_code(frames: &[Frame]) -> String { - let mut code = quote!(); - let mut tests = quote!(); - - let mut match_arms_name = quote! {}; - let mut match_arms_abbreviation = quote! {}; - let mut match_arms_from_str = quote! {}; - let mut match_arms_impl_pystate = quote! {}; - - frames.iter().for_each(|f| { - let ident = f.ident(); - let test_ident = format_ident!("test_reference_frame_{}", f.abbreviation.to_lowercase()); - let name = f.name; - let abbreviation = f.abbreviation; - let abbreviation_lowercase = abbreviation.to_lowercase(); - match_arms_name.extend(quote! { - PyFrame::#ident => #name.to_string(), - }); - match_arms_abbreviation.extend(quote! { - PyFrame::#ident => #abbreviation.to_string(), - }); - match_arms_from_str.extend(quote! { - #abbreviation | #abbreviation_lowercase => Ok(PyFrame::#ident), - }); - match_arms_impl_pystate.extend(if f.ident == "Icrf" { - quote! { - PyFrame::#ident => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(#ident, provider.get())? - .with_frame(PyFrame::#ident), - )), - None => Ok(PyState( - self.try_to_frame(#ident, &PyNoOpOffsetProvider)? - .with_frame(PyFrame::#ident), - )), - }, - } - } else { - quote! { - PyFrame::#ident => match provider { - Some(provider) => Ok(PyState( - self.try_to_frame(BodyFixed(#ident), provider.get())? - .with_frame(PyFrame::#ident), - )), - None => Ok(PyState( - self.try_to_frame(BodyFixed(#ident), &PyNoOpOffsetProvider)? - .with_frame(PyFrame::#ident), - )), - }, - - } - }); - - generate_transform(f, frames, &mut code); - - tests.extend(quote! { - #[test] - fn #test_ident() { - assert_eq!(PyFrame::#ident.name(), #name); - assert_eq!(PyFrame::#ident.abbreviation(), #abbreviation); - } - }) - }); - - code.extend(quote! { - impl PyState { - pub fn to_frame_generated( - &self, - frame: PyFrame, - provider: Option<&Bound<'_, PyUt1Provider>>, - ) -> PyResult { - match frame { - #match_arms_impl_pystate - } - } - } - - impl ReferenceFrame for PyFrame { - fn name(&self) -> String { - match self { - #match_arms_name - } - } - - fn abbreviation(&self) -> String { - match self { - #match_arms_abbreviation - } - } - } - - impl FromStr for PyFrame { - type Err = PyErr; - - fn from_str(s: &str) -> Result { - match s { - #match_arms_from_str - _ => Err(PyValueError::new_err("unknown reference frame")), - } - } - } - }); - - let module = quote! { - use crate::frames::{ - BodyFixed, CoordinateSystem, FrameTransformationProvider, Icrf, ReferenceFrame, TryToFrame, - }; - use crate::python::{PyFrame, PyState}; - use crate::states::State; - use lox_bodies::python::PyBody; - use lox_bodies::*; - use lox_time::python::time::PyTime; - use lox_time::python::ut1::{PyDeltaUt1Provider, PyNoOpOffsetProvider, PyUt1Provider}; - use pyo3::exceptions::PyValueError; - use pyo3::{Bound, PyErr, PyResult}; - use std::str::FromStr; - - #code - - #[cfg(test)] - #[allow(clippy::approx_constant)] // at least one parsed constant is close to TAU - mod tests { - use super::*; - - #tests - } - }; - module.to_string() -} - -pub fn generate_frames(dir: &Path) { - let frames = vec![ - Frame { - ident: "Icrf", - name: "International Celestial Reference Frame", - abbreviation: "ICRF", - is_bodyfixed: false, - }, - Frame { - ident: "Sun", - name: "IAU Body-Fixed Frame for the Sun", - abbreviation: "IAU_SUN", - is_bodyfixed: true, - }, - Frame { - ident: "Mercury", - name: "IAU Body-Fixed Frame for Mercury", - abbreviation: "IAU_MERCURY", - is_bodyfixed: true, - }, - Frame { - ident: "Venus", - name: "IAU Body-Fixed Frame for Venus", - abbreviation: "IAU_VENUS", - is_bodyfixed: true, - }, - Frame { - ident: "Earth", - name: "IAU Body-Fixed Frame for Earth", - abbreviation: "IAU_EARTH", - is_bodyfixed: true, - }, - Frame { - ident: "Mars", - name: "IAU Body-Fixed Frame for Mars", - abbreviation: "IAU_MARS", - is_bodyfixed: true, - }, - Frame { - ident: "Jupiter", - name: "IAU Body-Fixed Frame for Jupiter", - abbreviation: "IAU_JUPITER", - is_bodyfixed: true, - }, - Frame { - ident: "Saturn", - name: "IAU Body-Fixed Frame for Saturn", - abbreviation: "IAU_SATURN", - is_bodyfixed: true, - }, - Frame { - ident: "Uranus", - name: "IAU Body-Fixed Frame for Uranus", - abbreviation: "IAU_URANUS", - is_bodyfixed: true, - }, - Frame { - ident: "Neptune", - name: "IAU Body-Fixed Frame for Neptune", - abbreviation: "IAU_NEPTUNE", - is_bodyfixed: true, - }, - Frame { - ident: "Pluto", - name: "IAU Body-Fixed Frame for Pluto", - abbreviation: "IAU_PLUTO", - is_bodyfixed: true, - }, - Frame { - ident: "Moon", - name: "IAU Body-Fixed Frame for the Moon", - abbreviation: "IAU_MOON", - is_bodyfixed: true, - }, - Frame { - ident: "Phobos", - name: "IAU Body-Fixed Frame for Phobos", - abbreviation: "IAU_PHOBOS", - is_bodyfixed: true, - }, - Frame { - ident: "Deimos", - name: "IAU Body-Fixed Frame for Deimos", - abbreviation: "IAU_DEIMOS", - is_bodyfixed: true, - }, - Frame { - ident: "Io", - name: "IAU Body-Fixed Frame for Io", - abbreviation: "IAU_IO", - is_bodyfixed: true, - }, - Frame { - ident: "Europa", - name: "IAU Body-Fixed Frame for Europa", - abbreviation: "IAU_EUROPA", - is_bodyfixed: true, - }, - Frame { - ident: "Ganymede", - name: "IAU Body-Fixed Frame for Ganymede", - abbreviation: "IAU_GANYMEDE", - is_bodyfixed: true, - }, - Frame { - ident: "Callisto", - name: "IAU Body-Fixed Frame for Callisto", - abbreviation: "IAU_CALLISTO", - is_bodyfixed: true, - }, - Frame { - ident: "Amalthea", - name: "IAU Body-Fixed Frame for Amalthea", - abbreviation: "IAU_AMALTHEA", - is_bodyfixed: true, - }, - Frame { - ident: "Himalia", - name: "IAU Body-Fixed Frame for Himalia", - abbreviation: "IAU_HIMALIA", - is_bodyfixed: true, - }, - Frame { - ident: "Elara", - name: "IAU Body-Fixed Frame for Elara", - abbreviation: "IAU_ELARA", - is_bodyfixed: true, - }, - Frame { - ident: "Pasiphae", - name: "IAU Body-Fixed Frame for Pasiphae", - abbreviation: "IAU_PASIPHAE", - is_bodyfixed: true, - }, - Frame { - ident: "Sinope", - name: "IAU Body-Fixed Frame for Sinope", - abbreviation: "IAU_SINOPE", - is_bodyfixed: true, - }, - Frame { - ident: "Lysithea", - name: "IAU Body-Fixed Frame for Lysithea", - abbreviation: "IAU_LYSITHEA", - is_bodyfixed: true, - }, - Frame { - ident: "Carme", - name: "IAU Body-Fixed Frame for Carme", - abbreviation: "IAU_CARME", - is_bodyfixed: true, - }, - Frame { - ident: "Ananke", - name: "IAU Body-Fixed Frame for Ananke", - abbreviation: "IAU_ANANKE", - is_bodyfixed: true, - }, - Frame { - ident: "Leda", - name: "IAU Body-Fixed Frame for Leda", - abbreviation: "IAU_LEDA", - is_bodyfixed: true, - }, - Frame { - ident: "Thebe", - name: "IAU Body-Fixed Frame for Thebe", - abbreviation: "IAU_THEBE", - is_bodyfixed: true, - }, - Frame { - ident: "Adrastea", - name: "IAU Body-Fixed Frame for Adrastea", - abbreviation: "IAU_ADRASTEA", - is_bodyfixed: true, - }, - Frame { - ident: "Metis", - name: "IAU Body-Fixed Frame for Metis", - abbreviation: "IAU_METIS", - is_bodyfixed: true, - }, - Frame { - ident: "Callirrhoe", - name: "IAU Body-Fixed Frame for Callirrhoe", - abbreviation: "IAU_CALLIRRHOE", - is_bodyfixed: true, - }, - Frame { - ident: "Themisto", - name: "IAU Body-Fixed Frame for Themisto", - abbreviation: "IAU_THEMISTO", - is_bodyfixed: true, - }, - Frame { - ident: "Magaclite", - name: "IAU Body-Fixed Frame for Magaclite", - abbreviation: "IAU_MAGACLITE", - is_bodyfixed: true, - }, - Frame { - ident: "Taygete", - name: "IAU Body-Fixed Frame for Taygete", - abbreviation: "IAU_TAYGETE", - is_bodyfixed: true, - }, - Frame { - ident: "Chaldene", - name: "IAU Body-Fixed Frame for Chaldene", - abbreviation: "IAU_CHALDENE", - is_bodyfixed: true, - }, - Frame { - ident: "Harpalyke", - name: "IAU Body-Fixed Frame for Harpalyke", - abbreviation: "IAU_HARPALYKE", - is_bodyfixed: true, - }, - Frame { - ident: "Kalyke", - name: "IAU Body-Fixed Frame for Kalyke", - abbreviation: "IAU_KALYKE", - is_bodyfixed: true, - }, - Frame { - ident: "Iocaste", - name: "IAU Body-Fixed Frame for Iocaste", - abbreviation: "IAU_IOCASTE", - is_bodyfixed: true, - }, - Frame { - ident: "Erinome", - name: "IAU Body-Fixed Frame for Erinome", - abbreviation: "IAU_ERINOME", - is_bodyfixed: true, - }, - Frame { - ident: "Isonoe", - name: "IAU Body-Fixed Frame for Isonoe", - abbreviation: "IAU_ISONOE", - is_bodyfixed: true, - }, - Frame { - ident: "Praxidike", - name: "IAU Body-Fixed Frame for Praxidike", - abbreviation: "IAU_PRAXIDIKE", - is_bodyfixed: true, - }, - Frame { - ident: "Autonoe", - name: "IAU Body-Fixed Frame for Autonoe", - abbreviation: "IAU_AUTONOE", - is_bodyfixed: true, - }, - Frame { - ident: "Thyone", - name: "IAU Body-Fixed Frame for Thyone", - abbreviation: "IAU_THYONE", - is_bodyfixed: true, - }, - Frame { - ident: "Hermippe", - name: "IAU Body-Fixed Frame for Hermippe", - abbreviation: "IAU_HERMIPPE", - is_bodyfixed: true, - }, - Frame { - ident: "Aitne", - name: "IAU Body-Fixed Frame for Aitne", - abbreviation: "IAU_AITNE", - is_bodyfixed: true, - }, - Frame { - ident: "Eurydome", - name: "IAU Body-Fixed Frame for Eurydome", - abbreviation: "IAU_EURYDOME", - is_bodyfixed: true, - }, - Frame { - ident: "Euanthe", - name: "IAU Body-Fixed Frame for Euanthe", - abbreviation: "IAU_EUANTHE", - is_bodyfixed: true, - }, - Frame { - ident: "Euporie", - name: "IAU Body-Fixed Frame for Euporie", - abbreviation: "IAU_EUPORIE", - is_bodyfixed: true, - }, - Frame { - ident: "Orthosie", - name: "IAU Body-Fixed Frame for Orthosie", - abbreviation: "IAU_ORTHOSIE", - is_bodyfixed: true, - }, - Frame { - ident: "Sponde", - name: "IAU Body-Fixed Frame for Sponde", - abbreviation: "IAU_SPONDE", - is_bodyfixed: true, - }, - Frame { - ident: "Kale", - name: "IAU Body-Fixed Frame for Kale", - abbreviation: "IAU_KALE", - is_bodyfixed: true, - }, - Frame { - ident: "Pasithee", - name: "IAU Body-Fixed Frame for Pasithee", - abbreviation: "IAU_PASITHEE", - is_bodyfixed: true, - }, - Frame { - ident: "Hegemone", - name: "IAU Body-Fixed Frame for Hegemone", - abbreviation: "IAU_HEGEMONE", - is_bodyfixed: true, - }, - Frame { - ident: "Mneme", - name: "IAU Body-Fixed Frame for Mneme", - abbreviation: "IAU_MNEME", - is_bodyfixed: true, - }, - Frame { - ident: "Aoede", - name: "IAU Body-Fixed Frame for Aoede", - abbreviation: "IAU_AOEDE", - is_bodyfixed: true, - }, - Frame { - ident: "Thelxinoe", - name: "IAU Body-Fixed Frame for Thelxinoe", - abbreviation: "IAU_THELXINOE", - is_bodyfixed: true, - }, - Frame { - ident: "Arche", - name: "IAU Body-Fixed Frame for Arche", - abbreviation: "IAU_ARCHE", - is_bodyfixed: true, - }, - Frame { - ident: "Kallichore", - name: "IAU Body-Fixed Frame for Kallichore", - abbreviation: "IAU_KALLICHORE", - is_bodyfixed: true, - }, - Frame { - ident: "Helike", - name: "IAU Body-Fixed Frame for Helike", - abbreviation: "IAU_HELIKE", - is_bodyfixed: true, - }, - Frame { - ident: "Carpo", - name: "IAU Body-Fixed Frame for Carpo", - abbreviation: "IAU_CARPO", - is_bodyfixed: true, - }, - Frame { - ident: "Eukelade", - name: "IAU Body-Fixed Frame for Eukelade", - abbreviation: "IAU_EUKELADE", - is_bodyfixed: true, - }, - Frame { - ident: "Cyllene", - name: "IAU Body-Fixed Frame for Cyllene", - abbreviation: "IAU_CYLLENE", - is_bodyfixed: true, - }, - Frame { - ident: "Kore", - name: "IAU Body-Fixed Frame for Kore", - abbreviation: "IAU_KORE", - is_bodyfixed: true, - }, - Frame { - ident: "Herse", - name: "IAU Body-Fixed Frame for Herse", - abbreviation: "IAU_HERSE", - is_bodyfixed: true, - }, - Frame { - ident: "Dia", - name: "IAU Body-Fixed Frame for Dia", - abbreviation: "IAU_DIA", - is_bodyfixed: true, - }, - Frame { - ident: "Mimas", - name: "IAU Body-Fixed Frame for Mimas", - abbreviation: "IAU_MIMAS", - is_bodyfixed: true, - }, - Frame { - ident: "Enceladus", - name: "IAU Body-Fixed Frame for Enceladus", - abbreviation: "IAU_ENCELADUS", - is_bodyfixed: true, - }, - Frame { - ident: "Tethys", - name: "IAU Body-Fixed Frame for Tethys", - abbreviation: "IAU_TETHYS", - is_bodyfixed: true, - }, - Frame { - ident: "Dione", - name: "IAU Body-Fixed Frame for Dione", - abbreviation: "IAU_DIONE", - is_bodyfixed: true, - }, - Frame { - ident: "Rhea", - name: "IAU Body-Fixed Frame for Rhea", - abbreviation: "IAU_RHEA", - is_bodyfixed: true, - }, - Frame { - ident: "Titan", - name: "IAU Body-Fixed Frame for Titan", - abbreviation: "IAU_TITAN", - is_bodyfixed: true, - }, - Frame { - ident: "Hyperion", - name: "IAU Body-Fixed Frame for Hyperion", - abbreviation: "IAU_HYPERION", - is_bodyfixed: true, - }, - Frame { - ident: "Iapetus", - name: "IAU Body-Fixed Frame for Iapetus", - abbreviation: "IAU_IAPETUS", - is_bodyfixed: true, - }, - Frame { - ident: "Phoebe", - name: "IAU Body-Fixed Frame for Phoebe", - abbreviation: "IAU_PHOEBE", - is_bodyfixed: true, - }, - Frame { - ident: "Janus", - name: "IAU Body-Fixed Frame for Janus", - abbreviation: "IAU_JANUS", - is_bodyfixed: true, - }, - Frame { - ident: "Epimetheus", - name: "IAU Body-Fixed Frame for Epimetheus", - abbreviation: "IAU_EPIMETHEUS", - is_bodyfixed: true, - }, - Frame { - ident: "Helene", - name: "IAU Body-Fixed Frame for Helene", - abbreviation: "IAU_HELENE", - is_bodyfixed: true, - }, - Frame { - ident: "Telesto", - name: "IAU Body-Fixed Frame for Telesto", - abbreviation: "IAU_TELESTO", - is_bodyfixed: true, - }, - Frame { - ident: "Calypso", - name: "IAU Body-Fixed Frame for Calypso", - abbreviation: "IAU_CALYPSO", - is_bodyfixed: true, - }, - Frame { - ident: "Atlas", - name: "IAU Body-Fixed Frame for Atlas", - abbreviation: "IAU_ATLAS", - is_bodyfixed: true, - }, - Frame { - ident: "Prometheus", - name: "IAU Body-Fixed Frame for Prometheus", - abbreviation: "IAU_PROMETHEUS", - is_bodyfixed: true, - }, - Frame { - ident: "Pandora", - name: "IAU Body-Fixed Frame for Pandora", - abbreviation: "IAU_PANDORA", - is_bodyfixed: true, - }, - Frame { - ident: "Pan", - name: "IAU Body-Fixed Frame for Pan", - abbreviation: "IAU_PAN", - is_bodyfixed: true, - }, - Frame { - ident: "Ymir", - name: "IAU Body-Fixed Frame for Ymir", - abbreviation: "IAU_YMIR", - is_bodyfixed: true, - }, - Frame { - ident: "Paaliaq", - name: "IAU Body-Fixed Frame for Paaliaq", - abbreviation: "IAU_PAALIAQ", - is_bodyfixed: true, - }, - Frame { - ident: "Tarvos", - name: "IAU Body-Fixed Frame for Tarvos", - abbreviation: "IAU_TARVOS", - is_bodyfixed: true, - }, - Frame { - ident: "Ijiraq", - name: "IAU Body-Fixed Frame for Ijiraq", - abbreviation: "IAU_IJIRAQ", - is_bodyfixed: true, - }, - Frame { - ident: "Suttungr", - name: "IAU Body-Fixed Frame for Suttungr", - abbreviation: "IAU_SUTTUNGR", - is_bodyfixed: true, - }, - Frame { - ident: "Kiviuq", - name: "IAU Body-Fixed Frame for Kiviuq", - abbreviation: "IAU_KIVIUQ", - is_bodyfixed: true, - }, - Frame { - ident: "Mundilfari", - name: "IAU Body-Fixed Frame for Mundilfari", - abbreviation: "IAU_MUNDILFARI", - is_bodyfixed: true, - }, - Frame { - ident: "Albiorix", - name: "IAU Body-Fixed Frame for Albiorix", - abbreviation: "IAU_ALBIORIX", - is_bodyfixed: true, - }, - Frame { - ident: "Skathi", - name: "IAU Body-Fixed Frame for Skathi", - abbreviation: "IAU_SKATHI", - is_bodyfixed: true, - }, - Frame { - ident: "Erriapus", - name: "IAU Body-Fixed Frame for Erriapus", - abbreviation: "IAU_ERRIAPUS", - is_bodyfixed: true, - }, - Frame { - ident: "Siarnaq", - name: "IAU Body-Fixed Frame for Siarnaq", - abbreviation: "IAU_SIARNAQ", - is_bodyfixed: true, - }, - Frame { - ident: "Thrymr", - name: "IAU Body-Fixed Frame for Thrymr", - abbreviation: "IAU_THRYMR", - is_bodyfixed: true, - }, - Frame { - ident: "Narvi", - name: "IAU Body-Fixed Frame for Narvi", - abbreviation: "IAU_NARVI", - is_bodyfixed: true, - }, - Frame { - ident: "Methone", - name: "IAU Body-Fixed Frame for Methone", - abbreviation: "IAU_METHONE", - is_bodyfixed: true, - }, - Frame { - ident: "Pallene", - name: "IAU Body-Fixed Frame for Pallene", - abbreviation: "IAU_PALLENE", - is_bodyfixed: true, - }, - Frame { - ident: "Polydeuces", - name: "IAU Body-Fixed Frame for Polydeuces", - abbreviation: "IAU_POLYDEUCES", - is_bodyfixed: true, - }, - Frame { - ident: "Daphnis", - name: "IAU Body-Fixed Frame for Daphnis", - abbreviation: "IAU_DAPHNIS", - is_bodyfixed: true, - }, - Frame { - ident: "Aegir", - name: "IAU Body-Fixed Frame for Aegir", - abbreviation: "IAU_AEGIR", - is_bodyfixed: true, - }, - Frame { - ident: "Bebhionn", - name: "IAU Body-Fixed Frame for Bebhionn", - abbreviation: "IAU_BEBHIONN", - is_bodyfixed: true, - }, - Frame { - ident: "Bergelmir", - name: "IAU Body-Fixed Frame for Bergelmir", - abbreviation: "IAU_BERGELMIR", - is_bodyfixed: true, - }, - Frame { - ident: "Bestla", - name: "IAU Body-Fixed Frame for Bestla", - abbreviation: "IAU_BESTLA", - is_bodyfixed: true, - }, - Frame { - ident: "Farbauti", - name: "IAU Body-Fixed Frame for Farbauti", - abbreviation: "IAU_FARBAUTI", - is_bodyfixed: true, - }, - Frame { - ident: "Fenrir", - name: "IAU Body-Fixed Frame for Fenrir", - abbreviation: "IAU_FENRIR", - is_bodyfixed: true, - }, - Frame { - ident: "Fornjot", - name: "IAU Body-Fixed Frame for Fornjot", - abbreviation: "IAU_FORNJOT", - is_bodyfixed: true, - }, - Frame { - ident: "Hati", - name: "IAU Body-Fixed Frame for Hati", - abbreviation: "IAU_HATI", - is_bodyfixed: true, - }, - Frame { - ident: "Hyrrokkin", - name: "IAU Body-Fixed Frame for Hyrrokkin", - abbreviation: "IAU_HYRROKKIN", - is_bodyfixed: true, - }, - Frame { - ident: "Kari", - name: "IAU Body-Fixed Frame for Kari", - abbreviation: "IAU_KARI", - is_bodyfixed: true, - }, - Frame { - ident: "Loge", - name: "IAU Body-Fixed Frame for Loge", - abbreviation: "IAU_LOGE", - is_bodyfixed: true, - }, - Frame { - ident: "Skoll", - name: "IAU Body-Fixed Frame for Skoll", - abbreviation: "IAU_SKOLL", - is_bodyfixed: true, - }, - Frame { - ident: "Surtur", - name: "IAU Body-Fixed Frame for Surtur", - abbreviation: "IAU_SURTUR", - is_bodyfixed: true, - }, - Frame { - ident: "Anthe", - name: "IAU Body-Fixed Frame for Anthe", - abbreviation: "IAU_ANTHE", - is_bodyfixed: true, - }, - Frame { - ident: "Jarnsaxa", - name: "IAU Body-Fixed Frame for Jarnsaxa", - abbreviation: "IAU_JARNSAXA", - is_bodyfixed: true, - }, - Frame { - ident: "Greip", - name: "IAU Body-Fixed Frame for Greip", - abbreviation: "IAU_GREIP", - is_bodyfixed: true, - }, - Frame { - ident: "Tarqeq", - name: "IAU Body-Fixed Frame for Tarqeq", - abbreviation: "IAU_TARQEQ", - is_bodyfixed: true, - }, - Frame { - ident: "Aegaeon", - name: "IAU Body-Fixed Frame for Aegaeon", - abbreviation: "IAU_AEGAEON", - is_bodyfixed: true, - }, - Frame { - ident: "Ariel", - name: "IAU Body-Fixed Frame for Ariel", - abbreviation: "IAU_ARIEL", - is_bodyfixed: true, - }, - Frame { - ident: "Umbriel", - name: "IAU Body-Fixed Frame for Umbriel", - abbreviation: "IAU_UMBRIEL", - is_bodyfixed: true, - }, - Frame { - ident: "Titania", - name: "IAU Body-Fixed Frame for Titania", - abbreviation: "IAU_TITANIA", - is_bodyfixed: true, - }, - Frame { - ident: "Oberon", - name: "IAU Body-Fixed Frame for Oberon", - abbreviation: "IAU_OBERON", - is_bodyfixed: true, - }, - Frame { - ident: "Miranda", - name: "IAU Body-Fixed Frame for Miranda", - abbreviation: "IAU_MIRANDA", - is_bodyfixed: true, - }, - Frame { - ident: "Cordelia", - name: "IAU Body-Fixed Frame for Cordelia", - abbreviation: "IAU_CORDELIA", - is_bodyfixed: true, - }, - Frame { - ident: "Ophelia", - name: "IAU Body-Fixed Frame for Ophelia", - abbreviation: "IAU_OPHELIA", - is_bodyfixed: true, - }, - Frame { - ident: "Bianca", - name: "IAU Body-Fixed Frame for Bianca", - abbreviation: "IAU_BIANCA", - is_bodyfixed: true, - }, - Frame { - ident: "Cressida", - name: "IAU Body-Fixed Frame for Cressida", - abbreviation: "IAU_CRESSIDA", - is_bodyfixed: true, - }, - Frame { - ident: "Desdemona", - name: "IAU Body-Fixed Frame for Desdemona", - abbreviation: "IAU_DESDEMONA", - is_bodyfixed: true, - }, - Frame { - ident: "Juliet", - name: "IAU Body-Fixed Frame for Juliet", - abbreviation: "IAU_JULIET", - is_bodyfixed: true, - }, - Frame { - ident: "Portia", - name: "IAU Body-Fixed Frame for Portia", - abbreviation: "IAU_PORTIA", - is_bodyfixed: true, - }, - Frame { - ident: "Rosalind", - name: "IAU Body-Fixed Frame for Rosalind", - abbreviation: "IAU_ROSALIND", - is_bodyfixed: true, - }, - Frame { - ident: "Belinda", - name: "IAU Body-Fixed Frame for Belinda", - abbreviation: "IAU_BELINDA", - is_bodyfixed: true, - }, - Frame { - ident: "Puck", - name: "IAU Body-Fixed Frame for Puck", - abbreviation: "IAU_PUCK", - is_bodyfixed: true, - }, - Frame { - ident: "Caliban", - name: "IAU Body-Fixed Frame for Caliban", - abbreviation: "IAU_CALIBAN", - is_bodyfixed: true, - }, - Frame { - ident: "Sycorax", - name: "IAU Body-Fixed Frame for Sycorax", - abbreviation: "IAU_SYCORAX", - is_bodyfixed: true, - }, - Frame { - ident: "Prospero", - name: "IAU Body-Fixed Frame for Prospero", - abbreviation: "IAU_PROSPERO", - is_bodyfixed: true, - }, - Frame { - ident: "Setebos", - name: "IAU Body-Fixed Frame for Setebos", - abbreviation: "IAU_SETEBOS", - is_bodyfixed: true, - }, - Frame { - ident: "Stephano", - name: "IAU Body-Fixed Frame for Stephano", - abbreviation: "IAU_STEPHANO", - is_bodyfixed: true, - }, - Frame { - ident: "Trinculo", - name: "IAU Body-Fixed Frame for Trinculo", - abbreviation: "IAU_TRINCULO", - is_bodyfixed: true, - }, - Frame { - ident: "Francisco", - name: "IAU Body-Fixed Frame for Francisco", - abbreviation: "IAU_FRANCISCO", - is_bodyfixed: true, - }, - Frame { - ident: "Margaret", - name: "IAU Body-Fixed Frame for Margaret", - abbreviation: "IAU_MARGARET", - is_bodyfixed: true, - }, - Frame { - ident: "Ferdinand", - name: "IAU Body-Fixed Frame for Ferdinand", - abbreviation: "IAU_FERDINAND", - is_bodyfixed: true, - }, - Frame { - ident: "Perdita", - name: "IAU Body-Fixed Frame for Perdita", - abbreviation: "IAU_PERDITA", - is_bodyfixed: true, - }, - Frame { - ident: "Mab", - name: "IAU Body-Fixed Frame for Mab", - abbreviation: "IAU_MAB", - is_bodyfixed: true, - }, - Frame { - ident: "Cupid", - name: "IAU Body-Fixed Frame for Cupid", - abbreviation: "IAU_CUPID", - is_bodyfixed: true, - }, - Frame { - ident: "Triton", - name: "IAU Body-Fixed Frame for Triton", - abbreviation: "IAU_TRITON", - is_bodyfixed: true, - }, - Frame { - ident: "Nereid", - name: "IAU Body-Fixed Frame for Nereid", - abbreviation: "IAU_NEREID", - is_bodyfixed: true, - }, - Frame { - ident: "Naiad", - name: "IAU Body-Fixed Frame for Naiad", - abbreviation: "IAU_NAIAD", - is_bodyfixed: true, - }, - Frame { - ident: "Thalassa", - name: "IAU Body-Fixed Frame for Thalassa", - abbreviation: "IAU_THALASSA", - is_bodyfixed: true, - }, - Frame { - ident: "Despina", - name: "IAU Body-Fixed Frame for Despina", - abbreviation: "IAU_DESPINA", - is_bodyfixed: true, - }, - Frame { - ident: "Galatea", - name: "IAU Body-Fixed Frame for Galatea", - abbreviation: "IAU_GALATEA", - is_bodyfixed: true, - }, - Frame { - ident: "Larissa", - name: "IAU Body-Fixed Frame for Larissa", - abbreviation: "IAU_LARISSA", - is_bodyfixed: true, - }, - Frame { - ident: "Proteus", - name: "IAU Body-Fixed Frame for Proteus", - abbreviation: "IAU_PROTEUS", - is_bodyfixed: true, - }, - Frame { - ident: "Halimede", - name: "IAU Body-Fixed Frame for Halimede", - abbreviation: "IAU_HALIMEDE", - is_bodyfixed: true, - }, - Frame { - ident: "Psamathe", - name: "IAU Body-Fixed Frame for Psamathe", - abbreviation: "IAU_PSAMATHE", - is_bodyfixed: true, - }, - Frame { - ident: "Sao", - name: "IAU Body-Fixed Frame for Sao", - abbreviation: "IAU_SAO", - is_bodyfixed: true, - }, - Frame { - ident: "Laomedeia", - name: "IAU Body-Fixed Frame for Laomedeia", - abbreviation: "IAU_LAOMEDEIA", - is_bodyfixed: true, - }, - Frame { - ident: "Neso", - name: "IAU Body-Fixed Frame for Neso", - abbreviation: "IAU_NESO", - is_bodyfixed: true, - }, - Frame { - ident: "Charon", - name: "IAU Body-Fixed Frame for Charon", - abbreviation: "IAU_CHARON", - is_bodyfixed: true, - }, - Frame { - ident: "Nix", - name: "IAU Body-Fixed Frame for Nix", - abbreviation: "IAU_NIX", - is_bodyfixed: true, - }, - Frame { - ident: "Hydra", - name: "IAU Body-Fixed Frame for Hydra", - abbreviation: "IAU_HYDRA", - is_bodyfixed: true, - }, - Frame { - ident: "Kerberos", - name: "IAU Body-Fixed Frame for Kerberos", - abbreviation: "IAU_KERBEROS", - is_bodyfixed: true, - }, - Frame { - ident: "Styx", - name: "IAU Body-Fixed Frame for Styx", - abbreviation: "IAU_STYX", - is_bodyfixed: true, - }, - Frame { - ident: "Gaspra", - name: "IAU Body-Fixed Frame for Gaspra", - abbreviation: "IAU_GASPRA", - is_bodyfixed: true, - }, - Frame { - ident: "Ida", - name: "IAU Body-Fixed Frame for Ida", - abbreviation: "IAU_IDA", - is_bodyfixed: true, - }, - Frame { - ident: "Dactyl", - name: "IAU Body-Fixed Frame for Dactyl", - abbreviation: "IAU_DACTYL", - is_bodyfixed: true, - }, - Frame { - ident: "Ceres", - name: "IAU Body-Fixed Frame for Ceres", - abbreviation: "IAU_CERES", - is_bodyfixed: true, - }, - Frame { - ident: "Pallas", - name: "IAU Body-Fixed Frame for Pallas", - abbreviation: "IAU_PALLAS", - is_bodyfixed: true, - }, - Frame { - ident: "Vesta", - name: "IAU Body-Fixed Frame for Vesta", - abbreviation: "IAU_VESTA", - is_bodyfixed: true, - }, - Frame { - ident: "Psyche", - name: "IAU Body-Fixed Frame for Psyche", - abbreviation: "IAU_PSYCHE", - is_bodyfixed: true, - }, - Frame { - ident: "Lutetia", - name: "IAU Body-Fixed Frame for Lutetia", - abbreviation: "IAU_LUTETIA", - is_bodyfixed: true, - }, - Frame { - ident: "Kleopatra", - name: "IAU Body-Fixed Frame for Kleopatra", - abbreviation: "IAU_KLEOPATRA", - is_bodyfixed: true, - }, - Frame { - ident: "Eros", - name: "IAU Body-Fixed Frame for Eros", - abbreviation: "IAU_EROS", - is_bodyfixed: true, - }, - Frame { - ident: "Davida", - name: "IAU Body-Fixed Frame for Davida", - abbreviation: "IAU_DAVIDA", - is_bodyfixed: true, - }, - Frame { - ident: "Mathilde", - name: "IAU Body-Fixed Frame for Mathilde", - abbreviation: "IAU_MATHILDE", - is_bodyfixed: true, - }, - Frame { - ident: "Steins", - name: "IAU Body-Fixed Frame for Steins", - abbreviation: "IAU_STEINS", - is_bodyfixed: true, - }, - Frame { - ident: "Braille", - name: "IAU Body-Fixed Frame for Braille", - abbreviation: "IAU_BRAILLE", - is_bodyfixed: true, - }, - Frame { - ident: "WilsonHarrington", - name: "IAU Body-Fixed Frame for Wilson-Harrington", - abbreviation: "IAU_WILSON_HARRINGTON", - is_bodyfixed: true, - }, - Frame { - ident: "Toutatis", - name: "IAU Body-Fixed Frame for Toutatis", - abbreviation: "IAU_TOUTATIS", - is_bodyfixed: true, - }, - Frame { - ident: "Itokawa", - name: "IAU Body-Fixed Frame for Itokawa", - abbreviation: "IAU_ITOKAWA", - is_bodyfixed: true, - }, - Frame { - ident: "Bennu", - name: "IAU Body-Fixed Frame for Bennu", - abbreviation: "IAU_BENNU", - is_bodyfixed: true, - }, - ]; - - let mut code = String::from(COPYRIGHT_NOTICE); - code.push_str(AUTO_GENERATION_NOTICE); - code.push_str(&generate_code(&frames)); - - let out = dir.join("generated.rs"); - fs::write(&out, code).expect("file should be writeable"); - - Command::new("rustfmt") - .args([out.to_str().unwrap()]) - .status() - .expect("formatting should work"); -} diff --git a/tools/lox-gen/src/generators.rs b/tools/lox-gen/src/generators.rs deleted file mode 100644 index 0c83caea..00000000 --- a/tools/lox-gen/src/generators.rs +++ /dev/null @@ -1,258 +0,0 @@ -/* - * 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/. - */ - -use proc_macro2::{Ident, TokenStream}; -use quote::{format_ident, quote}; - -use lox_io::spice::Kernel; - -use crate::bodies::BodyDef; -use crate::rotational_elements::{CoefficientKernel, RotationalElements}; - -pub trait Generator { - fn imports(&self) -> Vec; - fn generate_code(&self, code: &mut TokenStream, tests: &mut TokenStream, body: &BodyDef); -} - -pub struct BaseGenerator; - -impl Generator for BaseGenerator { - fn imports(&self) -> Vec { - vec![] - } - - fn generate_code(&self, code: &mut TokenStream, _tests: &mut TokenStream, body: &BodyDef) { - let ident = body.ident(); - - code.extend(quote! { - #[derive(Debug, Copy, Clone, Eq, PartialEq)] - pub struct #ident; - }); - - if let Some(body_trait) = body.body_trait() { - code.extend(quote! { - impl #body_trait for #ident {} - }) - } - } -} - -pub struct BodyGenerator; - -impl Generator for BodyGenerator { - fn imports(&self) -> Vec { - vec![format_ident!("Body"), format_ident!("NaifId")] - } - - fn generate_code(&self, code: &mut TokenStream, tests: &mut TokenStream, body: &BodyDef) { - let ident = body.ident(); - let name = body.name; - let id = body.id; - - code.extend(quote! { - impl Body for #ident { - fn id(&self) -> NaifId { - NaifId(#id) - } - - fn name(&self) -> &'static str { - #name - } - } - - impl Display for #ident { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } - } - }); - - let test = test_name("body", body); - - tests.extend(quote! { - #[test] - fn #test() { - assert_eq!(#ident.id(), NaifId(#id)); - assert_eq!(#ident.name(), #name); - assert_eq!(format!("{}", #ident), #name); - } - }); - } -} - -pub struct SpheroidGenerator { - pub pck: Kernel, -} - -impl Generator for SpheroidGenerator { - fn imports(&self) -> Vec { - vec![format_ident!("Ellipsoid"), format_ident!("Spheroid")] - } - - fn generate_code(&self, code: &mut TokenStream, tests: &mut TokenStream, body: &BodyDef) { - let ident = body.ident(); - let id = body.id; - - let radii = format!("BODY{id}_RADII"); - if let Some(radii) = self.pck.get_double_array(&radii) { - let equatorial = radii.first().expect("radius should be here"); - let polar = radii.get(2).expect("radius should be here"); - let mean = (2.0 * equatorial + polar) / 3.0; - - code.extend(quote! { - impl Ellipsoid for #ident { - fn polar_radius(&self) -> f64 { - #polar - } - fn mean_radius(&self) -> f64 { - #mean - } - } - - impl Spheroid for #ident { - fn equatorial_radius(&self) -> f64 { - #equatorial - } - } - }); - - let test = test_name("spheroid", body); - - tests.extend(quote! { - #[test] - fn #test() { - assert_eq!(#ident.polar_radius(), #polar); - assert_eq!(#ident.mean_radius(), #mean); - assert_eq!(#ident.equatorial_radius(), #equatorial); - } - }); - } - } -} - -pub struct TriAxialGenerator { - pub pck: Kernel, -} - -impl Generator for TriAxialGenerator { - fn imports(&self) -> Vec { - vec![format_ident!("Ellipsoid"), format_ident!("TriAxial")] - } - - fn generate_code(&self, code: &mut TokenStream, tests: &mut TokenStream, body: &BodyDef) { - let ident = body.ident(); - let id = body.id; - let key = format!("BODY{id}_RADII"); - if let Some(radii) = self.pck.get_double_array(&key) { - let subplanetary = radii.first().expect("radius should be here"); - let along_orbit = radii.get(1).expect("radius should be here"); - let polar = radii.get(2).expect("radius should be here"); - let mean = (subplanetary + along_orbit + polar) / 3.0; - - code.extend(quote! { - impl Ellipsoid for #ident { - fn polar_radius(&self) -> f64 { - #polar - } - fn mean_radius(&self) -> f64 { - #mean - } - } - - impl TriAxial for #ident { - fn subplanetary_radius(&self) -> f64 { - #subplanetary - } - fn along_orbit_radius(&self) -> f64 { - #along_orbit - } - } - }); - - let test = test_name("tri_axial", body); - - tests.extend(quote! { - #[test] - fn #test() { - assert_eq!(#ident.polar_radius(), #polar); - assert_eq!(#ident.mean_radius(), #mean); - assert_eq!(#ident.subplanetary_radius(), #subplanetary); - assert_eq!(#ident.along_orbit_radius(), #along_orbit); - } - }); - } - } -} - -pub struct PointMassGenerator { - pub gm: Kernel, -} - -impl Generator for PointMassGenerator { - fn imports(&self) -> Vec { - vec![format_ident!("PointMass")] - } - - fn generate_code(&self, code: &mut TokenStream, tests: &mut TokenStream, body: &BodyDef) { - let ident = body.ident(); - let id = body.id; - - let key = format!("BODY{id}_GM"); - if let Some(gm) = self.gm.get_double_array(&key) { - let gm = gm.first().unwrap(); - code.extend(quote! { - impl PointMass for #ident { - fn gravitational_parameter(&self) -> f64 { - #gm - } - } - }); - - let test = test_name("point_mass", body); - - tests.extend(quote! { - #[test] - fn #test() { - assert_eq!(#ident.gravitational_parameter(), #gm); - } - }); - }; - } -} - -pub struct RotationalElementsGenerator { - pub pck: Kernel, -} - -impl Generator for RotationalElementsGenerator { - fn imports(&self) -> Vec { - vec![ - format_ident!("RotationalElements"), - format_ident!("PolynomialCoefficients"), - format_ident!("NutationPrecessionCoefficients"), - ] - } - - fn generate_code(&self, code: &mut TokenStream, tests: &mut TokenStream, body: &BodyDef) { - let ident = body.ident(); - let id = body.id; - - let elements = - match RotationalElements::parse(id as u32, &ident, CoefficientKernel(&self.pck)) { - Ok(elements) => elements, - Err(err) => panic!("failed to parse rotational elements for {}: {}", ident, err), - }; - - code.extend(elements.code_tokens()); - tests.extend(elements.test_tokens()); - } -} - -fn test_name(trait_name: &str, body: &BodyDef) -> Ident { - format_ident!("test_{}_{}", trait_name, body.id as u32) -} diff --git a/tools/lox-gen/src/main.rs b/tools/lox-gen/src/main.rs index 93ba900d..d9840f8a 100644 --- a/tools/lox-gen/src/main.rs +++ b/tools/lox-gen/src/main.rs @@ -8,29 +8,21 @@ use std::path::PathBuf; +use crate::origins::generate_bodies; use lox_io::spice::Kernel; -use crate::frames::generate_frames; -use crate::modules::generate_modules; - -mod bodies; mod common; -mod frames; -mod generators; -mod modules; -mod rotational_elements; +mod origins; fn crates_dir() -> PathBuf { PathBuf::from(format!("{}/../../crates", env!("CARGO_MANIFEST_DIR"))) } pub fn main() { - let pck = Kernel::from_string(include_str!("../../../data/pck00011.tpc")) + let pck = Kernel::from_string(include_str!("../../../data/pck00011_n0066.tpc")) .expect("parsing should succeed"); let gm = Kernel::from_string(include_str!("../../../data/gm_de440.tpc")) .expect("parsing should succeed"); - let bodies_target_dir = crates_dir().join("lox-bodies/src/generated/"); - generate_modules(&bodies_target_dir, &pck, &gm); - let frames_target_dir = crates_dir().join("lox-orbits/src/python/"); - generate_frames(&frames_target_dir); + let bodies_target_dir = crates_dir().join("lox-bodies/src/"); + generate_bodies(&bodies_target_dir, &pck, &gm); } diff --git a/tools/lox-gen/src/modules.rs b/tools/lox-gen/src/modules.rs deleted file mode 100644 index 7809e077..00000000 --- a/tools/lox-gen/src/modules.rs +++ /dev/null @@ -1,1092 +0,0 @@ -/* - * 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/. - */ - -use std::collections::HashSet; -use std::fs; -use std::path::Path; -use std::process::Command; - -use proc_macro2::Ident; -use quote::quote; - -use lox_io::spice::Kernel; - -use crate::bodies::BodyDef; -use crate::common::{AUTO_GENERATION_NOTICE, COPYRIGHT_NOTICE}; -use crate::generators::{ - BaseGenerator, BodyGenerator, Generator, PointMassGenerator, RotationalElementsGenerator, - SpheroidGenerator, TriAxialGenerator, -}; - -pub fn generate_modules(dir: &Path, pck: &Kernel, gm: &Kernel) { - let modules = vec![ - Module { - name: "sun", - bodies: vec![BodyDef { - name: "Sun", - id: 10, - body_trait: None, - }], - generators: vec![ - Box::new(BaseGenerator), - Box::new(BodyGenerator), - Box::new(SpheroidGenerator { pck: pck.clone() }), - Box::new(PointMassGenerator { gm: gm.clone() }), - Box::new(RotationalElementsGenerator { pck: pck.clone() }), - ], - }, - Module { - name: "barycenters", - bodies: vec![ - BodyDef { - name: "Solar System Barycenter", - id: 0, - body_trait: Some("Barycenter"), - }, - BodyDef { - name: "Mercury Barycenter", - id: 1, - body_trait: Some("Barycenter"), - }, - BodyDef { - name: "Venus Barycenter", - id: 2, - body_trait: Some("Barycenter"), - }, - BodyDef { - name: "Earth Barycenter", - id: 3, - body_trait: Some("Barycenter"), - }, - BodyDef { - name: "Mars Barycenter", - id: 4, - body_trait: Some("Barycenter"), - }, - BodyDef { - name: "Jupiter Barycenter", - id: 5, - body_trait: Some("Barycenter"), - }, - BodyDef { - name: "Saturn Barycenter", - id: 6, - body_trait: Some("Barycenter"), - }, - BodyDef { - name: "Uranus Barycenter", - id: 7, - body_trait: Some("Barycenter"), - }, - BodyDef { - name: "Neptune Barycenter", - id: 8, - body_trait: Some("Barycenter"), - }, - BodyDef { - name: "Pluto Barycenter", - id: 9, - body_trait: Some("Barycenter"), - }, - ], - generators: vec![ - Box::new(BaseGenerator), - Box::new(BodyGenerator), - Box::new(PointMassGenerator { gm: gm.clone() }), - ], - }, - Module { - name: "planets", - bodies: vec![ - BodyDef { - name: "Mercury", - id: 199, - body_trait: Some("Planet"), - }, - BodyDef { - name: "Venus", - id: 299, - body_trait: Some("Planet"), - }, - BodyDef { - name: "Earth", - id: 399, - body_trait: Some("Planet"), - }, - BodyDef { - name: "Mars", - id: 499, - body_trait: Some("Planet"), - }, - BodyDef { - name: "Jupiter", - id: 599, - body_trait: Some("Planet"), - }, - BodyDef { - name: "Saturn", - id: 699, - body_trait: Some("Planet"), - }, - BodyDef { - name: "Uranus", - id: 799, - body_trait: Some("Planet"), - }, - BodyDef { - name: "Neptune", - id: 899, - body_trait: Some("Planet"), - }, - BodyDef { - name: "Pluto", - id: 999, - body_trait: Some("Planet"), - }, - ], - generators: vec![ - Box::new(BaseGenerator), - Box::new(BodyGenerator), - Box::new(SpheroidGenerator { pck: pck.clone() }), - Box::new(PointMassGenerator { gm: gm.clone() }), - Box::new(RotationalElementsGenerator { pck: pck.clone() }), - ], - }, - Module { - name: "satellites", - bodies: vec![ - BodyDef { - name: "Moon", - id: 301, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Phobos", - id: 401, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Deimos", - id: 402, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Io", - id: 501, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Europa", - id: 502, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Ganymede", - id: 503, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Callisto", - id: 504, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Amalthea", - id: 505, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Himalia", - id: 506, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Elara", - id: 507, - body_trait: None, - }, - BodyDef { - name: "Pasiphae", - id: 508, - body_trait: None, - }, - BodyDef { - name: "Sinope", - id: 509, - body_trait: None, - }, - BodyDef { - name: "Lysithea", - id: 510, - body_trait: None, - }, - BodyDef { - name: "Carme", - id: 511, - body_trait: None, - }, - BodyDef { - name: "Ananke", - id: 512, - body_trait: None, - }, - BodyDef { - name: "Leda", - id: 513, - body_trait: None, - }, - BodyDef { - name: "Thebe", - id: 514, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Adrastea", - id: 515, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Metis", - id: 516, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Callirrhoe", - id: 517, - body_trait: None, - }, - BodyDef { - name: "Themisto", - id: 518, - body_trait: None, - }, - BodyDef { - name: "Magaclite", - id: 519, - body_trait: None, - }, - BodyDef { - name: "Taygete", - id: 520, - body_trait: None, - }, - BodyDef { - name: "Chaldene", - id: 521, - body_trait: None, - }, - BodyDef { - name: "Harpalyke", - id: 522, - body_trait: None, - }, - BodyDef { - name: "Kalyke", - id: 523, - body_trait: None, - }, - BodyDef { - name: "Iocaste", - id: 524, - body_trait: None, - }, - BodyDef { - name: "Erinome", - id: 525, - body_trait: None, - }, - BodyDef { - name: "Isonoe", - id: 526, - body_trait: None, - }, - BodyDef { - name: "Praxidike", - id: 527, - body_trait: None, - }, - BodyDef { - name: "Autonoe", - id: 528, - body_trait: None, - }, - BodyDef { - name: "Thyone", - id: 529, - body_trait: None, - }, - BodyDef { - name: "Hermippe", - id: 530, - body_trait: None, - }, - BodyDef { - name: "Aitne", - id: 531, - body_trait: None, - }, - BodyDef { - name: "Eurydome", - id: 532, - body_trait: None, - }, - BodyDef { - name: "Euanthe", - id: 533, - body_trait: None, - }, - BodyDef { - name: "Euporie", - id: 534, - body_trait: None, - }, - BodyDef { - name: "Orthosie", - id: 535, - body_trait: None, - }, - BodyDef { - name: "Sponde", - id: 536, - body_trait: None, - }, - BodyDef { - name: "Kale", - id: 537, - body_trait: None, - }, - BodyDef { - name: "Pasithee", - id: 538, - body_trait: None, - }, - BodyDef { - name: "Hegemone", - id: 539, - body_trait: None, - }, - BodyDef { - name: "Mneme", - id: 540, - body_trait: None, - }, - BodyDef { - name: "Aoede", - id: 541, - body_trait: None, - }, - BodyDef { - name: "Thelxinoe", - id: 542, - body_trait: None, - }, - BodyDef { - name: "Arche", - id: 543, - body_trait: None, - }, - BodyDef { - name: "Kallichore", - id: 544, - body_trait: None, - }, - BodyDef { - name: "Helike", - id: 545, - body_trait: None, - }, - BodyDef { - name: "Carpo", - id: 546, - body_trait: None, - }, - BodyDef { - name: "Eukelade", - id: 547, - body_trait: None, - }, - BodyDef { - name: "Cyllene", - id: 548, - body_trait: None, - }, - BodyDef { - name: "Kore", - id: 549, - body_trait: None, - }, - BodyDef { - name: "Herse", - id: 550, - body_trait: None, - }, - BodyDef { - name: "Dia", - id: 553, - body_trait: None, - }, - BodyDef { - name: "Mimas", - id: 601, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Enceladus", - id: 602, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Tethys", - id: 603, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Dione", - id: 604, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Rhea", - id: 605, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Titan", - id: 606, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Hyperion", - id: 607, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Iapetus", - id: 608, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Phoebe", - id: 609, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Janus", - id: 610, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Epimetheus", - id: 611, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Helene", - id: 612, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Telesto", - id: 613, - body_trait: None, - }, - BodyDef { - name: "Calypso", - id: 614, - body_trait: None, - }, - BodyDef { - name: "Atlas", - id: 615, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Prometheus", - id: 616, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Pandora", - id: 617, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Pan", - id: 618, - body_trait: None, - }, - BodyDef { - name: "Ymir", - id: 619, - body_trait: None, - }, - BodyDef { - name: "Paaliaq", - id: 620, - body_trait: None, - }, - BodyDef { - name: "Tarvos", - id: 621, - body_trait: None, - }, - BodyDef { - name: "Ijiraq", - id: 622, - body_trait: None, - }, - BodyDef { - name: "Suttungr", - id: 623, - body_trait: None, - }, - BodyDef { - name: "Kiviuq", - id: 624, - body_trait: None, - }, - BodyDef { - name: "Mundilfari", - id: 625, - body_trait: None, - }, - BodyDef { - name: "Albiorix", - id: 626, - body_trait: None, - }, - BodyDef { - name: "Skathi", - id: 627, - body_trait: None, - }, - BodyDef { - name: "Erriapus", - id: 628, - body_trait: None, - }, - BodyDef { - name: "Siarnaq", - id: 629, - body_trait: None, - }, - BodyDef { - name: "Thrymr", - id: 630, - body_trait: None, - }, - BodyDef { - name: "Narvi", - id: 631, - body_trait: None, - }, - BodyDef { - name: "Methone", - id: 632, - body_trait: None, - }, - BodyDef { - name: "Pallene", - id: 633, - body_trait: None, - }, - BodyDef { - name: "Polydeuces", - id: 634, - body_trait: None, - }, - BodyDef { - name: "Daphnis", - id: 635, - body_trait: None, - }, - BodyDef { - name: "Aegir", - id: 636, - body_trait: None, - }, - BodyDef { - name: "Bebhionn", - id: 637, - body_trait: None, - }, - BodyDef { - name: "Bergelmir", - id: 638, - body_trait: None, - }, - BodyDef { - name: "Bestla", - id: 639, - body_trait: None, - }, - BodyDef { - name: "Farbauti", - id: 640, - body_trait: None, - }, - BodyDef { - name: "Fenrir", - id: 641, - body_trait: None, - }, - BodyDef { - name: "Fornjot", - id: 642, - body_trait: None, - }, - BodyDef { - name: "Hati", - id: 643, - body_trait: None, - }, - BodyDef { - name: "Hyrrokkin", - id: 644, - body_trait: None, - }, - BodyDef { - name: "Kari", - id: 645, - body_trait: None, - }, - BodyDef { - name: "Loge", - id: 646, - body_trait: None, - }, - BodyDef { - name: "Skoll", - id: 647, - body_trait: None, - }, - BodyDef { - name: "Surtur", - id: 648, - body_trait: None, - }, - BodyDef { - name: "Anthe", - id: 649, - body_trait: None, - }, - BodyDef { - name: "Jarnsaxa", - id: 650, - body_trait: None, - }, - BodyDef { - name: "Greip", - id: 651, - body_trait: None, - }, - BodyDef { - name: "Tarqeq", - id: 652, - body_trait: None, - }, - BodyDef { - name: "Aegaeon", - id: 653, - body_trait: None, - }, - BodyDef { - name: "Ariel", - id: 701, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Umbriel", - id: 702, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Titania", - id: 703, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Oberon", - id: 704, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Miranda", - id: 705, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Cordelia", - id: 706, - body_trait: None, - }, - BodyDef { - name: "Ophelia", - id: 707, - body_trait: None, - }, - BodyDef { - name: "Bianca", - id: 708, - body_trait: None, - }, - BodyDef { - name: "Cressida", - id: 709, - body_trait: None, - }, - BodyDef { - name: "Desdemona", - id: 710, - body_trait: None, - }, - BodyDef { - name: "Juliet", - id: 711, - body_trait: None, - }, - BodyDef { - name: "Portia", - id: 712, - body_trait: None, - }, - BodyDef { - name: "Rosalind", - id: 713, - body_trait: None, - }, - BodyDef { - name: "Belinda", - id: 714, - body_trait: None, - }, - BodyDef { - name: "Puck", - id: 715, - body_trait: None, - }, - BodyDef { - name: "Caliban", - id: 716, - body_trait: None, - }, - BodyDef { - name: "Sycorax", - id: 717, - body_trait: None, - }, - BodyDef { - name: "Prospero", - id: 718, - body_trait: None, - }, - BodyDef { - name: "Setebos", - id: 719, - body_trait: None, - }, - BodyDef { - name: "Stephano", - id: 720, - body_trait: None, - }, - BodyDef { - name: "Trinculo", - id: 721, - body_trait: None, - }, - BodyDef { - name: "Francisco", - id: 722, - body_trait: None, - }, - BodyDef { - name: "Margaret", - id: 723, - body_trait: None, - }, - BodyDef { - name: "Ferdinand", - id: 724, - body_trait: None, - }, - BodyDef { - name: "Perdita", - id: 725, - body_trait: None, - }, - BodyDef { - name: "Mab", - id: 726, - body_trait: None, - }, - BodyDef { - name: "Cupid", - id: 727, - body_trait: None, - }, - BodyDef { - name: "Triton", - id: 801, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Nereid", - id: 802, - body_trait: None, - }, - BodyDef { - name: "Naiad", - id: 803, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Thalassa", - id: 804, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Despina", - id: 805, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Galatea", - id: 806, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Larissa", - id: 807, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Proteus", - id: 808, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Halimede", - id: 809, - body_trait: None, - }, - BodyDef { - name: "Psamathe", - id: 810, - body_trait: None, - }, - BodyDef { - name: "Sao", - id: 811, - body_trait: None, - }, - BodyDef { - name: "Laomedeia", - id: 812, - body_trait: None, - }, - BodyDef { - name: "Neso", - id: 813, - body_trait: None, - }, - BodyDef { - name: "Charon", - id: 901, - body_trait: Some("Satellite"), - }, - BodyDef { - name: "Nix", - id: 902, - body_trait: None, - }, - BodyDef { - name: "Hydra", - id: 903, - body_trait: None, - }, - BodyDef { - name: "Kerberos", - id: 904, - body_trait: None, - }, - BodyDef { - name: "Styx", - id: 905, - body_trait: None, - }, - ], - generators: vec![ - Box::new(BaseGenerator), - Box::new(BodyGenerator), - Box::new(TriAxialGenerator { pck: pck.clone() }), - Box::new(PointMassGenerator { gm: gm.clone() }), - Box::new(RotationalElementsGenerator { pck: pck.clone() }), - ], - }, - Module { - name: "minor", - bodies: vec![ - BodyDef { - name: "Gaspra", - id: 9511010, - body_trait: None, - }, - BodyDef { - name: "Ida", - id: 2431010, - body_trait: None, - }, - BodyDef { - name: "Dactyl", - id: 2431011, - body_trait: None, - }, - BodyDef { - name: "Ceres", - id: 2000001, - body_trait: Some("MinorBody"), - }, - BodyDef { - name: "Pallas", - id: 2000002, - body_trait: None, - }, - BodyDef { - name: "Vesta", - id: 2000004, - body_trait: Some("MinorBody"), - }, - BodyDef { - name: "Psyche", - id: 2000016, - body_trait: Some("MinorBody"), - }, - BodyDef { - name: "Lutetia", - id: 2000021, - body_trait: None, - }, - BodyDef { - name: "Kleopatra", - id: 2000216, - body_trait: None, - }, - BodyDef { - name: "Eros", - id: 2000433, - body_trait: Some("MinorBody"), - }, - BodyDef { - name: "Davida", - id: 2000511, - body_trait: Some("MinorBody"), - }, - BodyDef { - name: "Mathilde", - id: 2000253, - body_trait: None, - }, - BodyDef { - name: "Steins", - id: 2002867, - body_trait: None, - }, - BodyDef { - name: "Braille", - id: 2009969, - body_trait: None, - }, - BodyDef { - name: "Wilson-Harrington", - id: 2004015, - body_trait: None, - }, - BodyDef { - name: "Toutatis", - id: 2004179, - body_trait: None, - }, - BodyDef { - name: "Itokawa", - id: 2025143, - body_trait: None, - }, - BodyDef { - name: "Bennu", - id: 2101955, - body_trait: None, - }, - ], - generators: vec![ - Box::new(BaseGenerator), - Box::new(BodyGenerator), - Box::new(TriAxialGenerator { pck: pck.clone() }), - Box::new(PointMassGenerator { gm: gm.clone() }), - Box::new(RotationalElementsGenerator { pck: pck.clone() }), - ], - }, - ]; - - modules.iter().for_each(|module| module.write(dir)); -} - -struct Module { - name: &'static str, - bodies: Vec, - generators: Vec>, -} - -impl Module { - fn write(&self, dir: &Path) { - let mut code = String::from(COPYRIGHT_NOTICE); - code.push_str(AUTO_GENERATION_NOTICE); - code.push_str(&self.generate_code()); - - let out = dir.join(format!("{}.rs", self.name)); - fs::write(&out, code).expect("file should be writeable"); - - Command::new("rustfmt") - .args([out.to_str().unwrap()]) - .status() - .expect("formatting should work"); - } - - fn generate_code(&self) -> String { - let mut imports: HashSet = HashSet::new(); - let mut code = quote!(); - let mut tests = quote!(); - - self.bodies.iter().for_each(|body| { - body.body_trait() - .map(|body_trait| imports.insert(body_trait)); - self.generators.iter().for_each(|generator| { - generator.generate_code(&mut code, &mut tests, body); - imports.extend(generator.imports()); - }); - }); - - let imports_iter = imports.iter(); - let module = quote! { - use std::fmt::{Display, Formatter}; - - use crate::{#(#imports_iter),*}; - - #code - - #[cfg(test)] - #[allow(clippy::approx_constant)] // at least one parsed constant is close to TAU - mod tests { - use super::*; - - #tests - } - }; - module.to_string() - } -} diff --git a/tools/lox-gen/src/origins.rs b/tools/lox-gen/src/origins.rs new file mode 100644 index 00000000..eb6468f5 --- /dev/null +++ b/tools/lox-gen/src/origins.rs @@ -0,0 +1,1341 @@ +/* + * 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/. + */ +use crate::common::write_file; +use lox_io::spice::Kernel; +use proc_macro2::{Ident, TokenStream}; +use quote::{format_ident, quote}; +use std::collections::hash_map::Entry::Vacant; +use std::collections::HashMap; +use std::path::Path; + +struct Origin { + name: &'static str, + id: i32, + mean_radius: Option, +} + +const ORIGINS: [Origin; 190] = [ + Origin { + name: "Sun", + id: 10, + mean_radius: None, + }, + // Planets. + Origin { + name: "Mercury", + id: 199, + mean_radius: Some(2439.4), + }, + Origin { + name: "Venus", + id: 299, + mean_radius: Some(6051.8), + }, + Origin { + name: "Earth", + id: 399, + mean_radius: Some(6371.0084), + }, + Origin { + name: "Mars", + id: 499, + mean_radius: Some(3389.5), + }, + Origin { + name: "Jupiter", + id: 599, + mean_radius: Some(69911.0), + }, + Origin { + name: "Saturn", + id: 699, + mean_radius: Some(58232.0), + }, + Origin { + name: "Uranus", + id: 799, + mean_radius: Some(25362.0), + }, + Origin { + name: "Neptune", + id: 899, + mean_radius: Some(24622.0), + }, + Origin { + name: "Pluto", + id: 999, + mean_radius: Some(1188.3), + }, + // Barycenters. + Origin { + name: "Solar System Barycenter", + id: 0, + mean_radius: None, + }, + Origin { + name: "Mercury Barycenter", + id: 1, + mean_radius: None, + }, + Origin { + name: "Venus Barycenter", + id: 2, + mean_radius: None, + }, + Origin { + name: "Earth Barycenter", + id: 3, + mean_radius: None, + }, + Origin { + name: "Mars Barycenter", + id: 4, + mean_radius: None, + }, + Origin { + name: "Jupiter Barycenter", + id: 5, + mean_radius: None, + }, + Origin { + name: "Saturn Barycenter", + id: 6, + mean_radius: None, + }, + Origin { + name: "Uranus Barycenter", + id: 7, + mean_radius: None, + }, + Origin { + name: "Neptune Barycenter", + id: 8, + mean_radius: None, + }, + Origin { + name: "Pluto Barycenter", + id: 9, + mean_radius: None, + }, + // Satellites. + Origin { + name: "Moon", + id: 301, + mean_radius: Some(1737.4), + }, + Origin { + name: "Phobos", + id: 401, + mean_radius: Some(11.08), + }, + Origin { + name: "Deimos", + id: 402, + mean_radius: Some(6.2), + }, + Origin { + name: "Io", + id: 501, + mean_radius: Some(1821.49), + }, + Origin { + name: "Europa", + id: 502, + mean_radius: Some(1560.8), + }, + Origin { + name: "Ganymede", + id: 503, + mean_radius: Some(2631.2), + }, + Origin { + name: "Callisto", + id: 504, + mean_radius: Some(2410.3), + }, + Origin { + name: "Amalthea", + id: 505, + mean_radius: Some(83.5), + }, + Origin { + name: "Himalia", + id: 506, + mean_radius: Some(85.0), + }, + Origin { + name: "Elara", + id: 507, + mean_radius: Some(40.0), + }, + Origin { + name: "Pasiphae", + id: 508, + mean_radius: Some(18.0), + }, + Origin { + name: "Sinope", + id: 509, + mean_radius: Some(14.0), + }, + Origin { + name: "Lysithea", + id: 510, + mean_radius: Some(12.0), + }, + Origin { + name: "Carme", + id: 511, + mean_radius: Some(15.0), + }, + Origin { + name: "Ananke", + id: 512, + mean_radius: Some(10.0), + }, + Origin { + name: "Leda", + id: 513, + mean_radius: Some(5.0), + }, + Origin { + name: "Thebe", + id: 514, + mean_radius: Some(49.3), + }, + Origin { + name: "Adrastea", + id: 515, + mean_radius: Some(8.2), + }, + Origin { + name: "Metis", + id: 516, + mean_radius: Some(21.5), + }, + Origin { + name: "Callirrhoe", + id: 517, + mean_radius: None, + }, + Origin { + name: "Themisto", + id: 518, + mean_radius: None, + }, + Origin { + name: "Magaclite", + id: 519, + mean_radius: None, + }, + Origin { + name: "Taygete", + id: 520, + mean_radius: None, + }, + Origin { + name: "Chaldene", + id: 521, + mean_radius: None, + }, + Origin { + name: "Harpalyke", + id: 522, + mean_radius: None, + }, + Origin { + name: "Kalyke", + id: 523, + mean_radius: None, + }, + Origin { + name: "Iocaste", + id: 524, + mean_radius: None, + }, + Origin { + name: "Erinome", + id: 525, + mean_radius: None, + }, + Origin { + name: "Isonoe", + id: 526, + mean_radius: None, + }, + Origin { + name: "Praxidike", + id: 527, + mean_radius: None, + }, + Origin { + name: "Autonoe", + id: 528, + mean_radius: None, + }, + Origin { + name: "Thyone", + id: 529, + mean_radius: None, + }, + Origin { + name: "Hermippe", + id: 530, + mean_radius: None, + }, + Origin { + name: "Aitne", + id: 531, + mean_radius: None, + }, + Origin { + name: "Eurydome", + id: 532, + mean_radius: None, + }, + Origin { + name: "Euanthe", + id: 533, + mean_radius: None, + }, + Origin { + name: "Euporie", + id: 534, + mean_radius: None, + }, + Origin { + name: "Orthosie", + id: 535, + mean_radius: None, + }, + Origin { + name: "Sponde", + id: 536, + mean_radius: None, + }, + Origin { + name: "Kale", + id: 537, + mean_radius: None, + }, + Origin { + name: "Pasithee", + id: 538, + mean_radius: None, + }, + Origin { + name: "Hegemone", + id: 539, + mean_radius: None, + }, + Origin { + name: "Mneme", + id: 540, + mean_radius: None, + }, + Origin { + name: "Aoede", + id: 541, + mean_radius: None, + }, + Origin { + name: "Thelxinoe", + id: 542, + mean_radius: None, + }, + Origin { + name: "Arche", + id: 543, + mean_radius: None, + }, + Origin { + name: "Kallichore", + id: 544, + mean_radius: None, + }, + Origin { + name: "Helike", + id: 545, + mean_radius: None, + }, + Origin { + name: "Carpo", + id: 546, + mean_radius: None, + }, + Origin { + name: "Eukelade", + id: 547, + mean_radius: None, + }, + Origin { + name: "Cyllene", + id: 548, + mean_radius: None, + }, + Origin { + name: "Kore", + id: 549, + mean_radius: None, + }, + Origin { + name: "Herse", + id: 550, + mean_radius: None, + }, + Origin { + name: "Dia", + id: 553, + mean_radius: None, + }, + Origin { + name: "Mimas", + id: 601, + mean_radius: Some(198.2), + }, + Origin { + name: "Enceladus", + id: 602, + mean_radius: Some(252.1), + }, + Origin { + name: "Tethys", + id: 603, + mean_radius: Some(531.0), + }, + Origin { + name: "Dione", + id: 604, + mean_radius: Some(561.4), + }, + Origin { + name: "Rhea", + id: 605, + mean_radius: Some(763.5), + }, + Origin { + name: "Titan", + id: 606, + mean_radius: Some(2575.0), + }, + Origin { + name: "Hyperion", + id: 607, + mean_radius: Some(135.0), + }, + Origin { + name: "Iapetus", + id: 608, + mean_radius: Some(734.3), + }, + Origin { + name: "Phoebe", + id: 609, + mean_radius: Some(106.5), + }, + Origin { + name: "Janus", + id: 610, + mean_radius: Some(89.2), + }, + Origin { + name: "Epimetheus", + id: 611, + mean_radius: Some(58.2), + }, + Origin { + name: "Helene", + id: 612, + mean_radius: Some(18.0), + }, + Origin { + name: "Telesto", + id: 613, + mean_radius: Some(12.4), + }, + Origin { + name: "Calypso", + id: 614, + mean_radius: Some(9.6), + }, + Origin { + name: "Atlas", + id: 615, + mean_radius: Some(15.1), + }, + Origin { + name: "Prometheus", + id: 616, + mean_radius: Some(43.1), + }, + Origin { + name: "Pandora", + id: 617, + mean_radius: Some(40.6), + }, + Origin { + name: "Pan", + id: 618, + mean_radius: Some(14.0), + }, + Origin { + name: "Ymir", + id: 619, + mean_radius: None, + }, + Origin { + name: "Paaliaq", + id: 620, + mean_radius: None, + }, + Origin { + name: "Tarvos", + id: 621, + mean_radius: None, + }, + Origin { + name: "Ijiraq", + id: 622, + mean_radius: None, + }, + Origin { + name: "Suttungr", + id: 623, + mean_radius: None, + }, + Origin { + name: "Kiviuq", + id: 624, + mean_radius: None, + }, + Origin { + name: "Mundilfari", + id: 625, + mean_radius: None, + }, + Origin { + name: "Albiorix", + id: 626, + mean_radius: None, + }, + Origin { + name: "Skathi", + id: 627, + mean_radius: None, + }, + Origin { + name: "Erriapus", + id: 628, + mean_radius: None, + }, + Origin { + name: "Siarnaq", + id: 629, + mean_radius: None, + }, + Origin { + name: "Thrymr", + id: 630, + mean_radius: None, + }, + Origin { + name: "Narvi", + id: 631, + mean_radius: None, + }, + Origin { + name: "Methone", + id: 632, + mean_radius: Some(1.45), + }, + Origin { + name: "Pallene", + id: 633, + mean_radius: Some(2.23), + }, + Origin { + name: "Polydeuces", + id: 634, + mean_radius: Some(1.3), + }, + Origin { + name: "Daphnis", + id: 635, + mean_radius: Some(3.8), + }, + Origin { + name: "Aegir", + id: 636, + mean_radius: None, + }, + Origin { + name: "Bebhionn", + id: 637, + mean_radius: None, + }, + Origin { + name: "Bergelmir", + id: 638, + mean_radius: None, + }, + Origin { + name: "Bestla", + id: 639, + mean_radius: None, + }, + Origin { + name: "Farbauti", + id: 640, + mean_radius: None, + }, + Origin { + name: "Fenrir", + id: 641, + mean_radius: None, + }, + Origin { + name: "Fornjot", + id: 642, + mean_radius: None, + }, + Origin { + name: "Hati", + id: 643, + mean_radius: None, + }, + Origin { + name: "Hyrrokkin", + id: 644, + mean_radius: None, + }, + Origin { + name: "Kari", + id: 645, + mean_radius: None, + }, + Origin { + name: "Loge", + id: 646, + mean_radius: None, + }, + Origin { + name: "Skoll", + id: 647, + mean_radius: None, + }, + Origin { + name: "Surtur", + id: 648, + mean_radius: None, + }, + Origin { + name: "Anthe", + id: 649, + mean_radius: Some(0.5), + }, + Origin { + name: "Jarnsaxa", + id: 650, + mean_radius: None, + }, + Origin { + name: "Greip", + id: 651, + mean_radius: None, + }, + Origin { + name: "Tarqeq", + id: 652, + mean_radius: None, + }, + Origin { + name: "Aegaeon", + id: 653, + mean_radius: Some(0.33), + }, + Origin { + name: "Ariel", + id: 701, + mean_radius: Some(578.9), + }, + Origin { + name: "Umbriel", + id: 702, + mean_radius: Some(584.7), + }, + Origin { + name: "Titania", + id: 703, + mean_radius: Some(788.9), + }, + Origin { + name: "Oberon", + id: 704, + mean_radius: Some(761.4), + }, + Origin { + name: "Miranda", + id: 705, + mean_radius: Some(235.8), + }, + Origin { + name: "Cordelia", + id: 706, + mean_radius: Some(13.0), + }, + Origin { + name: "Ophelia", + id: 707, + mean_radius: Some(15.0), + }, + Origin { + name: "Bianca", + id: 708, + mean_radius: Some(21.0), + }, + Origin { + name: "Cressida", + id: 709, + mean_radius: Some(31.0), + }, + Origin { + name: "Desdemona", + id: 710, + mean_radius: Some(27.0), + }, + Origin { + name: "Juliet", + id: 711, + mean_radius: Some(42.0), + }, + Origin { + name: "Portia", + id: 712, + mean_radius: Some(54.0), + }, + Origin { + name: "Rosalind", + id: 713, + mean_radius: Some(27.0), + }, + Origin { + name: "Belinda", + id: 714, + mean_radius: Some(33.0), + }, + Origin { + name: "Puck", + id: 715, + mean_radius: Some(77.0), + }, + Origin { + name: "Caliban", + id: 716, + mean_radius: None, + }, + Origin { + name: "Sycorax", + id: 717, + mean_radius: None, + }, + Origin { + name: "Prospero", + id: 718, + mean_radius: None, + }, + Origin { + name: "Setebos", + id: 719, + mean_radius: None, + }, + Origin { + name: "Stephano", + id: 720, + mean_radius: None, + }, + Origin { + name: "Trinculo", + id: 721, + mean_radius: None, + }, + Origin { + name: "Francisco", + id: 722, + mean_radius: None, + }, + Origin { + name: "Margaret", + id: 723, + mean_radius: None, + }, + Origin { + name: "Ferdinand", + id: 724, + mean_radius: None, + }, + Origin { + name: "Perdita", + id: 725, + mean_radius: None, + }, + Origin { + name: "Mab", + id: 726, + mean_radius: None, + }, + Origin { + name: "Cupid", + id: 727, + mean_radius: None, + }, + Origin { + name: "Triton", + id: 801, + mean_radius: Some(1352.6), + }, + Origin { + name: "Nereid", + id: 802, + mean_radius: Some(170.0), + }, + Origin { + name: "Naiad", + id: 803, + mean_radius: Some(29.0), + }, + Origin { + name: "Thalassa", + id: 804, + mean_radius: Some(40.0), + }, + Origin { + name: "Despina", + id: 805, + mean_radius: Some(74.0), + }, + Origin { + name: "Galatea", + id: 806, + mean_radius: Some(79.0), + }, + Origin { + name: "Larissa", + id: 807, + mean_radius: Some(96.0), + }, + Origin { + name: "Proteus", + id: 808, + mean_radius: Some(208.0), + }, + Origin { + name: "Halimede", + id: 809, + mean_radius: None, + }, + Origin { + name: "Psamathe", + id: 810, + mean_radius: None, + }, + Origin { + name: "Sao", + id: 811, + mean_radius: None, + }, + Origin { + name: "Laomedeia", + id: 812, + mean_radius: None, + }, + Origin { + name: "Neso", + id: 813, + mean_radius: None, + }, + Origin { + name: "Charon", + id: 901, + mean_radius: Some(606.0), + }, + Origin { + name: "Nix", + id: 902, + mean_radius: None, + }, + Origin { + name: "Hydra", + id: 903, + mean_radius: None, + }, + Origin { + name: "Kerberos", + id: 904, + mean_radius: None, + }, + Origin { + name: "Styx", + id: 905, + mean_radius: None, + }, + // Minor bodies. + Origin { + name: "Gaspra", + id: 9511010, + mean_radius: Some(6.1), + }, + Origin { + name: "Ida", + id: 2431010, + mean_radius: Some(15.65), + }, + Origin { + name: "Dactyl", + id: 2431011, + mean_radius: None, + }, + Origin { + name: "Ceres", + id: 2000001, + mean_radius: Some(470.0), + }, + Origin { + name: "Pallas", + id: 2000002, + mean_radius: None, + }, + Origin { + name: "Vesta", + id: 2000004, + mean_radius: None, + }, + Origin { + name: "Psyche", + id: 2000016, + mean_radius: Some(113.0), + }, + Origin { + name: "Lutetia", + id: 2000021, + mean_radius: Some(52.5), + }, + Origin { + name: "Kleopatra", + id: 2000216, + mean_radius: None, + }, + Origin { + name: "Eros", + id: 2000433, + mean_radius: Some(8.45), + }, + Origin { + name: "Davida", + id: 2000511, + mean_radius: Some(150.0), + }, + Origin { + name: "Mathilde", + id: 2000253, + mean_radius: Some(26.5), + }, + Origin { + name: "Steins", + id: 2002867, + mean_radius: Some(2.7), + }, + Origin { + name: "Braille", + id: 2009969, + mean_radius: None, + }, + Origin { + name: "Wilson-Harrington", + id: 2004015, + mean_radius: None, + }, + Origin { + name: "Toutatis", + id: 2004179, + mean_radius: None, + }, + Origin { + name: "Itokawa", + id: 2025143, + mean_radius: None, + }, + Origin { + name: "Bennu", + id: 2101955, + mean_radius: None, + }, +]; + +fn ident(name: &str) -> Ident { + format_ident!("{}", name.replace([' ', '-'], "")) +} + +fn ident_uppercase(name: &str) -> Ident { + format_ident!("{}", name.replace([' ', '-'], "_").to_uppercase()) +} + +fn get_array_as_radians(kernel: &Kernel, key: &str) -> Option> { + kernel + .get_double_array(key) + .map(|array| array.iter().map(|v| v.to_radians()).collect()) +} + +fn unpair(vec: &[f64]) -> (Vec, Vec) { + let mut a: Vec = Vec::with_capacity(vec.len() / 2); + let mut b: Vec = Vec::with_capacity(vec.len() / 2); + for (i, coefficient) in vec.iter().enumerate() { + if i % 2 == 0 { + a.push(*coefficient); + } else { + b.push(*coefficient); + } + } + (a, b) +} + +pub fn generate_bodies(path: &Path, pck: &Kernel, gm: &Kernel) { + let mut code = quote! { + use crate::DynOrigin; + use crate::Elements; + use crate::MaybeMeanRadius; + use crate::MaybePointMass; + use crate::MaybeSpheroid; + use crate::MaybeTriaxialEllipsoid; + use crate::MeanRadius; + use crate::NaifId; + use crate::NutationPrecessionCoefficients; + use crate::Origin; + use crate::PointMass; + use crate::Radii; + use crate::RotationalElement; + use crate::RotationalElementType; + use crate::RotationalElements; + use crate::Spheroid; + use crate::TriaxialEllipsoid; + use crate::TryRotationalElements; + use crate::UndefinedRotationalElementsError; + use std::fmt::Display; + use std::fmt::Formatter; + }; + + let mut point_mass_match_arms = quote! {}; + let mut mean_radius_match_arms = quote! {}; + let mut ellipsoid_match_arms = quote! {}; + + let mut rotational_elements_match_arms = quote! {}; + let mut rotational_element_rates_match_arms = quote! {}; + + let mut nut_prec_ids: HashMap = HashMap::new(); + let mut nut_prec_lens: HashMap = HashMap::new(); + let mut nut_prec_constants = quote! {}; + + for Origin { + name, + id, + mean_radius, + } in ORIGINS + { + let ident = ident(name); + let ident_upper = ident_uppercase(name); + + code.extend(quote! { + + #[derive(Debug, Copy, Clone, Eq, PartialEq)] + pub struct #ident; + + impl Origin for #ident { + fn id(&self) -> NaifId { + NaifId(#id) + } + + fn name(&self) -> &'static str { + #name + } + } + + impl Display for #ident { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } + } + }); + + // PointMass + let key = if id == 0 { + "BODY10_GM".to_string() + } else { + format!("BODY{id}_GM") + }; + + if let Some(gm) = gm.get_double_array(&key) { + let gm = gm.first().unwrap(); + code.extend(quote! { + impl PointMass for #ident { + fn gravitational_parameter(&self) -> f64 { + #gm + } + } + }); + + point_mass_match_arms.extend(quote! { + DynOrigin::#ident => Some(#gm), + }); + }; + + // Barycenters do not have cartographic properties + if id < 10 { + continue; + } + + if let Some(mean_radius) = mean_radius { + code.extend(quote! { + impl MeanRadius for #ident { + fn mean_radius(&self) -> f64 { + #mean_radius + } + } + }); + + mean_radius_match_arms.extend(quote! { + DynOrigin::#ident => Some(#mean_radius), + }) + } + + // TriaxialEllipsoid / Spheroid + let key = format!("BODY{id}_RADII"); + + if let Some(radii) = pck.get_double_array(&key) { + code.extend(quote! { + impl TriaxialEllipsoid for #ident { + fn radii(&self) -> Radii { + (#(#radii),*) + } + } + }); + + if radii[0] == radii[1] { + code.extend(quote! { + impl Spheroid for #ident {} + }) + } + + ellipsoid_match_arms.extend(quote! { + DynOrigin::#ident => Some((#(#radii),*)), + }) + } + + let ra_key = format!("BODY{id}_POLE_RA"); + let dec_key = format!("BODY{id}_POLE_DEC"); + let pm_key = format!("BODY{id}_PM"); + let nut_prec_ra_key = format!("BODY{id}_NUT_PREC_RA"); + let nut_prec_dec_key = format!("BODY{id}_NUT_PREC_DEC"); + let nut_prec_pm_key = format!("BODY{id}_NUT_PREC_PM"); + + let nut_prec_id = id / 100; + let nut_prec_key = format!("BODY{}_NUT_PREC_ANGLES", nut_prec_id); + + if let Vacant(e) = nut_prec_ids.entry(nut_prec_id) { + let nut_prec_ident = format_ident!("NUTATION_PRECESSION_{}", ident_upper); + + match get_array_as_radians(pck, &nut_prec_key) { + None => { + e.insert(quote! { None }); + } + Some(coeffs) => { + e.insert(quote! { Some(&#nut_prec_ident) }); + + let n = coeffs.len() / 2; + nut_prec_lens.insert(nut_prec_id, n); + let (theta0, theta1) = unpair(&coeffs); + nut_prec_constants.extend(quote! { + const #nut_prec_ident: NutationPrecessionCoefficients<#n> = + NutationPrecessionCoefficients { + theta0: [#(#theta0),*], + theta1: [#(#theta1),*], + }; + }) + } + }; + } + + if let (Some(ra), Some(dec), Some(pm)) = ( + get_array_as_radians(pck, &ra_key), + get_array_as_radians(pck, &dec_key), + get_array_as_radians(pck, &pm_key), + ) { + let nut_prec_const = nut_prec_ids.get(&nut_prec_id).unwrap(); + let nut_prec_len = nut_prec_lens.get(&nut_prec_id).unwrap_or(&0); + + let ra1 = ra[0]; + let ra2 = ra[1]; + let ra3 = ra.get(2).copied().unwrap_or_default(); + let nut_prec_ra = get_array_as_radians(pck, &nut_prec_ra_key); + let n = nut_prec_ra.as_ref().map(|v| v.len()).unwrap_or_default(); + let nut_prec_ra = match nut_prec_ra { + None => quote! {None}, + Some(coeffs) => quote! { + Some([#(#coeffs),*]) + }, + }; + + let ra_const_ident = format_ident!("RIGHT_ASCENSION_{}", ident_upper); + let ra_const = quote! { + const #ra_const_ident: RotationalElement<#n> = RotationalElement { + typ: RotationalElementType::RightAscension, + c0: #ra1, + c1: #ra2, + c2: #ra3, + c: #nut_prec_ra, + }; + }; + let ra = quote! { + #ra_const_ident.angle::<#nut_prec_len>(#nut_prec_const, t) + }; + let ra_dot = quote! { + #ra_const_ident.angle_dot::<#nut_prec_len>(#nut_prec_const, t) + }; + + let dec1 = dec[0]; + let dec2 = dec[1]; + let dec3 = dec.get(2).copied().unwrap_or_default(); + let nut_prec_dec = get_array_as_radians(pck, &nut_prec_dec_key); + let n = nut_prec_dec.as_ref().map(|v| v.len()).unwrap_or_default(); + let nut_prec_dec = match nut_prec_dec { + None => quote! {None}, + Some(coeffs) => quote! { + Some([#(#coeffs),*]) + }, + }; + + let dec_const_ident = format_ident!("DECLINATION_{}", ident_upper); + let dec_const = quote! { + const #dec_const_ident: RotationalElement<#n> = RotationalElement { + typ: RotationalElementType::Declination, + c0: #dec1, + c1: #dec2, + c2: #dec3, + c: #nut_prec_dec, + }; + }; + let dec = quote! { + #dec_const_ident.angle::<#nut_prec_len>(#nut_prec_const, t) + }; + let dec_dot = quote! { + #dec_const_ident.angle_dot::<#nut_prec_len>(#nut_prec_const, t) + }; + + let pm1 = pm[0]; + let pm2 = pm[1]; + let pm3 = pm.get(2).copied().unwrap_or_default(); + let nut_prec_pm = get_array_as_radians(pck, &nut_prec_pm_key); + let n = nut_prec_pm.as_ref().map(|v| v.len()).unwrap_or_default(); + let nut_prec_pm = match nut_prec_pm { + None => quote! {None}, + Some(coeffs) => quote! { + Some([#(#coeffs),*]) + }, + }; + + let pm_const_ident = format_ident!("ROTATION_{}", ident_upper); + let pm_const = quote! { + const #pm_const_ident: RotationalElement<#n> = RotationalElement { + typ: RotationalElementType::Rotation, + c0: #pm1, + c1: #pm2, + c2: #pm3, + c: #nut_prec_pm, + }; + }; + let pm = quote! { + #pm_const_ident.angle::<#nut_prec_len>(#nut_prec_const, t) + }; + let pm_dot = quote! { + #pm_const_ident.angle_dot::<#nut_prec_len>(#nut_prec_const, t) + }; + + code.extend(quote! { + #ra_const + #dec_const + #pm_const + + impl RotationalElements for #ident { + fn rotational_elements(&self, t: f64) -> Elements { + (#ra, #dec, #pm) + } + fn rotational_element_rates(&self, t: f64) -> Elements { + (#ra_dot, #dec_dot, #pm_dot) + } + } + }); + + rotational_elements_match_arms.extend(quote! { + DynOrigin::#ident => Ok((#ra, #dec, #pm)), + }); + + rotational_element_rates_match_arms.extend(quote! { + DynOrigin::#ident => Ok((#ra_dot, #dec_dot, #pm_dot)), + }); + } + } + + code.extend(nut_prec_constants); + + code.extend(quote! { + impl MaybePointMass for DynOrigin { + fn maybe_gravitational_parameter(&self) -> Option { + match self { + #point_mass_match_arms + _ => None, + } + } + } + impl MaybeMeanRadius for DynOrigin { + fn maybe_mean_radius(&self) -> Option { + match self { + #mean_radius_match_arms + _ => None, + } + } + } + impl MaybeTriaxialEllipsoid for DynOrigin { + fn maybe_radii(&self) -> Option { + match self { + #ellipsoid_match_arms + _ => None, + } + } + } + impl MaybeSpheroid for DynOrigin {} + impl TryRotationalElements for DynOrigin { + fn try_rotational_elements(&self, t: f64) + -> Result { + match self { + #rotational_elements_match_arms + _ => Err(UndefinedRotationalElementsError(self.name().to_string())), + } + } + + fn try_rotational_element_rates( + &self, + t: f64, + ) -> Result { + match self { + #rotational_element_rates_match_arms + _ => Err(UndefinedRotationalElementsError(self.name().to_string())), + } + } + } + }); + + write_file(path, "generated.rs", code) +} diff --git a/tools/lox-gen/src/rotational_elements.rs b/tools/lox-gen/src/rotational_elements.rs deleted file mode 100644 index d15fc72c..00000000 --- a/tools/lox-gen/src/rotational_elements.rs +++ /dev/null @@ -1,345 +0,0 @@ -/* - * Copyright (c) 2023. 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/. - */ - -use proc_macro2::{Ident, TokenStream}; -use quote::{format_ident, quote, ToTokens}; -use thiserror::Error; - -use lox_io::spice::Kernel; - -/// Converts [lox_bodies::PolynomialCoefficients] into a TokenStream. -pub struct TokenizeablePolynomialCoefficients(f64, f64, f64, Vec); - -impl ToTokens for TokenizeablePolynomialCoefficients { - fn to_tokens(&self, tokens: &mut TokenStream) { - 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 [lox_bodies::NutationPrecessionCoefficients] into a TokenStream. -#[derive(Default)] -pub struct TokenizeableNutPrecCoefficients((Vec, Vec)); - -impl ToTokens for TokenizeableNutPrecCoefficients { - fn to_tokens(&self, tokens: &mut TokenStream) { - 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]) }); - } -} - -/// Holds the rotational elements for a given body. -/// -/// May be parsed directly from PCK data and knows how to represent its code and test components as -/// streams of tokens. -/// -/// Wherever data is not available for a given body, the corresponding field will be empty. -pub(crate) struct RotationalElements<'a> { - id: u32, - ident: &'a Ident, - right_ascension: TokenizeablePolynomialCoefficients, - declination: TokenizeablePolynomialCoefficients, - prime_meridian: TokenizeablePolynomialCoefficients, - - /// 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, -} - -impl<'a> RotationalElements<'a> { - pub(crate) fn parse( - id: u32, - ident: &'a Ident, - kernel: impl GetPolynomialCoefficients, - ) -> Result> { - Ok(Self { - id, - ident, - 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_bodies::BodyRotationalElements] impl. - pub(crate) fn code_tokens(&self) -> TokenStream { - let ident = self.ident; - 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; - - quote! { - #[allow(clippy::approx_constant)] - impl RotationalElements for #ident { - fn nutation_precession_coefficients(&self) -> NutationPrecessionCoefficients { - #barycenter_nut_prec - } - fn right_ascension_coefficients(&self) -> PolynomialCoefficients { - #right_ascension - } - fn declination_coefficients(&self) -> PolynomialCoefficients { - #declination - } - fn prime_meridian_coefficients(&self) -> PolynomialCoefficients { - #prime_meridian - } - } - } - } - - /// Returns the TokenStream testing the [lox_bodies::BodyRotationalElements] impl. - pub(crate) fn test_tokens(&self) -> TokenStream { - let ident = self.ident; - 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 - ); - - 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()) - } - - #[test] - fn #declination_test_name() { - assert_eq!(#declination, #ident.declination_coefficients()) - } - - #[test] - fn #prime_meridian_test_name() { - assert_eq!(#prime_meridian, #ident.prime_meridian_coefficients()) - } - } - } -} - -/// 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 }, -} - -/// GetPolynomialCoefficients supports translation between a raw PCK kernel and RotationalElements. -pub trait GetPolynomialCoefficients { - fn get_right_ascension_coefficients_or_default( - &self, - id: u32, - ) -> Result>; - - fn get_declination_coefficients_or_default( - &self, - id: u32, - ) -> Result>; - - fn get_prime_meridian_coefficients_or_default( - &self, - id: u32, - ) -> Result>; - - fn get_barycenter_nut_prec_coefficients_or_default( - &self, - barycenter_id: u32, - ) -> Result>; -} - -/// Concrete translator from a raw PCK kernel to RotationalElements. Produces coefficients in -/// radians. -pub struct CoefficientKernel<'a>(pub &'a Kernel); - -/// The type of coefficient to be retrieved from the kernel. -enum PolynomialCoefficientType { - RightAscension, - Declination, - PrimeMeridian, -} - -impl PolynomialCoefficientType { - /// Returns the pair of kernel keys required to retrieve the trig and non-trig coefficients for - /// a given body and coefficient type. - fn keys(&self, id: u32) -> (String, String) { - match self { - PolynomialCoefficientType::RightAscension => ( - format!("BODY{}_POLE_RA", id), - format!("BODY{}_NUT_PREC_RA", id), - ), - PolynomialCoefficientType::Declination => ( - format!("BODY{}_POLE_DEC", id), - format!("BODY{}_NUT_PREC_DEC", id), - ), - PolynomialCoefficientType::PrimeMeridian => { - (format!("BODY{}_PM", id), format!("BODY{}_NUT_PREC_PM", id)) - } - } - } -} - -impl GetPolynomialCoefficients for CoefficientKernel<'_> { - fn get_right_ascension_coefficients_or_default( - &self, - id: u32, - ) -> Result> { - self.get_polynomial_coefficients_or_default(id, PolynomialCoefficientType::RightAscension) - } - - fn get_declination_coefficients_or_default( - &self, - id: u32, - ) -> Result> { - self.get_polynomial_coefficients_or_default(id, PolynomialCoefficientType::Declination) - } - - fn get_prime_meridian_coefficients_or_default( - &self, - id: u32, - ) -> Result> { - self.get_polynomial_coefficients_or_default(id, PolynomialCoefficientType::PrimeMeridian) - } - - fn get_barycenter_nut_prec_coefficients_or_default( - &self, - id: u32, - ) -> Result> { - 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 vecs. - Some(coefficients) => { - let mut unpaired = unpair(coefficients); - unpaired.0.iter_mut().for_each(|c| *c = c.to_radians()); - unpaired.1.iter_mut().for_each(|c| *c = c.to_radians()); - Ok(TokenizeableNutPrecCoefficients(unpaired)) - } - } - } -} - -impl<'a> CoefficientKernel<'a> { - fn get_polynomial_coefficients_or_default( - &self, - id: u32, - pct: PolynomialCoefficientType, - ) -> Result> { - 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( - 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> { - match self.0.get_double_array(key) { - None => Ok([0.0; 3]), - Some(coefficients) if coefficients.len() < 2 => { - Err(Box::new(CoefficientsError::TooFew { - key: key.to_string(), - min: 2, - actual: coefficients.len(), - })) - } - Some(coefficients) if coefficients.len() > 3 => { - Err(Box::new(CoefficientsError::TooMany { - key: key.to_string(), - max: 3, - actual: coefficients.len(), - })) - } - Some(coefficients) => Ok([ - coefficients[0].to_radians(), - coefficients[1].to_radians(), - coefficients.get(2).copied().unwrap_or(0.0).to_radians(), - ]), - } - } - - fn get_nut_prec_coefficients_or_default( - &self, - key: &str, - ) -> Result, Box> { - match self.0.get_double_array(key) { - None => Ok(vec![]), - Some(coefficients) => Ok(coefficients.iter().map(|c| c.to_radians()).collect()), - } - } -} - -fn unpair(vec: &[f64]) -> (Vec, Vec) { - let mut a: Vec = Vec::with_capacity(vec.len() / 2); - let mut b: Vec = Vec::with_capacity(vec.len() / 2); - for (i, coefficient) in vec.iter().enumerate() { - if i % 2 == 0 { - a.push(*coefficient); - } else { - b.push(*coefficient); - } - } - (a, b) -}