Struct EstimationRecipe 

pub struct EstimationRecipe {
    pub range: RangeRecipe,
    pub sagnac: SagnacRecipe,
    pub frame: FrameRecipe,
    pub normal: NormalRecipe,
    pub solver: SolverRecipe,
}

The full operation-order recipe a strategy composes: one variant per stage. Default and the named constructors reproduce the CURRENT behavior of each existing strategy, so selecting a recipe never changes a reference golden.

Fields

range: RangeRecipe

sagnac: SagnacRecipe

frame: FrameRecipe

normal: NormalRecipe

solver: SolverRecipe

Implementations

impl EstimationRecipe

pub const fn spp() -> Self

The current SPP reference recipe (spp::solve, Skyfield-parity).

pub const fn rtk() -> Self

The current RTK reference recipe (rtk / rtk_filter, RTKLIB-parity).

pub const fn ppp() -> Self

The current PPP reference recipe (precise_positioning, oracle-parity).

pub const fn spp_owned_deterministic() -> Self

The SPP recipe driving the owned deterministic trust-region solver: the SPP reference model with SolverRecipe::OwnedDeterministicTrf swapped in for the legacy nalgebra LU linear-solve stage. Every other stage is the SPP reference op-order, so only the factorization changes.

pub const fn canonical_spp() -> Self

The canonical SPP recipe: the single consistent IERS-rigorous SPP measurement model. It diverges from Self::spp (the Skyfield-faithful reference) only where the physics says to:

• range: RangeRecipe::CanonicalLightTimeClosedFormSagnac iterates the light-time loop to convergence (vs the reference’s fixed transmit-time truncation), with the closed-form Sagnac Z-rotation (never a first-order scalar Sagnac).
• frame: FrameRecipe::CanonicalWgs84 solves ECEF->geodetic directly in meters on the WGS84 ellipsoid (vs the reference’s Skyfield AU-scaled three-iteration latitude loop).
• solver: SolverRecipe::OwnedDeterministicTrf owns the trust-region subproblem factorization so canonical is deterministic run-to-run on a pinned build (its cross-platform bit guarantee is scoped to the factorization; the surrounding reductions ride nalgebra).

The Sagnac stage is the closed-form Z-rotation the SPP reference already uses (the rigorous form), and the normal stage is the SPP weighted-residual finite-difference assembly the trust-region solver consumes; neither needs a separate canonical variant for SPP.

pub const fn canonical_rtk() -> Self

The canonical RTK recipe: the double-difference baseline under the numerically rigorous square-root-information solve. It keeps the RTK reference’s double-difference measurement physics (the provided-transmit range with the RTKLIB first-order Sagnac scalar, the geocentric-up elevation frame), because the canonical RTK divergence the physics calls for is in the linear algebra, not the observation model: the same SPD information system the reference assembles is solved by the owned deterministic Cholesky square-root factorization (NormalRecipe::CanonicalSquareRoot on SolverRecipe::OwnedDeterministicCholesky) instead of the reference’s general first-tie Gaussian elimination. The square-root solve needs no pivoting, exploits the symmetry of the SPD normal matrix, and is entirely owned scalar arithmetic (no nalgebra, no BLAS), so canonical RTK is well-conditioned and bit-reproducible across platforms.

pub const fn canonical_ppp() -> Self

The canonical PPP recipe: the undifferenced ionosphere-free PPP arc under the numerically rigorous square-root-information solve. Like Self::canonical_rtk it keeps the PPP reference’s measurement physics (the rounded-microsecond fixed-iteration light-time with the rigorous closed-form Sagnac Z-rotation, and the geodetic NEU antenna frame), because the canonical PPP divergence the physics calls for is in the linear algebra, not the observation model: the same dense SPD weighted normal system AᵀWA x = AᵀWy the reference assembles from the undifferenced rows is solved by the owned deterministic Cholesky square-root factorization (NormalRecipe::CanonicalSquareRoot on SolverRecipe::OwnedDeterministicCholesky) instead of the reference’s dense last-tie Gaussian elimination (SolverRecipe::DenseGaussianLastTie). The square-root solve needs no pivoting, exploits the symmetry of the SPD normal matrix, and is entirely owned scalar arithmetic (no nalgebra, no BLAS), so it is well-conditioned and the solve itself is bit-portable. Determinism scope (calibrated, not overstated): unlike canonical RTK, the PPP measurement model that builds the rows evaluates troposphere mapping, antenna, and geodetic-frame transcendentals through the platform math library, so canonical PPP’s overall output is bit-reproducible run-to-run on a pinned build but is not claimed bit-portable across platforms; only the owned Cholesky solve carries the cross-platform guarantee.

pub const fn for_canonical(technique: Technique) -> Option<Self>

The canonical recipe for a technique. Canonical SPP (P6 increment 1), canonical RTK (P6 increment 2), and canonical PPP (P6 increment 3) are all wired, so every technique has a canonical strategy. Returns Option to keep the resolver’s “not yet implemented” surface stable.

pub const fn for_reference( technique: Technique, target: ReferenceTarget, ) -> Option<Self>

The reference recipe for an explicit (technique, target) pair, or None if the pair is not a supported reference strategy. This is the single source of truth for which targets each technique can run: only the wired reference oracles (Skyfield for SPP, RTKLIB for RTK, the PPP oracle for PPP) and the SPP owned deterministic solver are valid. Every other pair (a cross-technique oracle, or the unwired scipy host-LAPACK reference) is rejected so an impossible strategy can never silently run a mismatched recipe.

Trait Implementations

impl Clone for EstimationRecipe

fn clone(&self) -> EstimationRecipe

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for EstimationRecipe

impl Debug for EstimationRecipe

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for EstimationRecipe

fn default() -> EstimationRecipe

Returns the “default value” for a type.

impl Eq for EstimationRecipe

impl Hash for EstimationRecipe

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for EstimationRecipe

fn eq(&self, other: &EstimationRecipe) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for EstimationRecipe