Struct Position 

pub struct Position {
    pub x: Real,
    pub y: Real,
    pub z: Real,
}

A 3-dimensional position vector expressed in Cartesian coordinates (x, y, z) with units of meters (SI).

This type is designed for high-precision relativistic calculations in space navigation, deep-space tracking, and interplanetary timing. Positions are typically expressed in a heliocentric (Sun-centered) reference frame because the dominant gravitational light-time correction—the Shapiro delay—is calculated with respect to the Sun.

Fields

x: Real

y: Real

z: Real

Implementations

impl Position

pub const ZERO: Self

The zero vector, representing the origin of the coordinate system (commonly the center of the Sun).

pub const fn new(x: Real, y: Real, z: Real) -> Self

Creates a new Position directly from its Cartesian components in meters.

pub const fn from_au(x: Real, y: Real, z: Real) -> Self

Creates a Position from coordinates expressed in Astronomical Units (AU), converting them to meters using the IAU 2012 definition (1 AU = 149 597 870 700 m).

Especially convenient when working with planetary ephemerides or solar-system models that are natively given in AU.

pub const fn norm(self) -> Real

Returns the Euclidean norm (straight-line distance) of this position from the origin.

When the position is Sun-centered, this is the radial distance from the Sun required for Shapiro-delay calculations.

pub const fn distance_to(self, other: Self) -> Real

Computes the straight-line (Euclidean) distance between this position and another Position.

Together with the two radial distances from the Sun, this value supplies the three geometric inputs needed to evaluate the Shapiro delay.

pub const fn lerp(self, other: Self, t: Real) -> Self

Returns a new position that lies a fraction t of the way along the straight line between self and other.

This is known as linear interpolation (lerp). It is most commonly used when you need to generate evenly spaced sample points along a path — for example, when building the samples slice for [ObserverState::one_way_relativistic_delay_integrated].

Parameters

• other – the ending position
• t – interpolation parameter (0.0 = start point, 1.0 = end point). Values outside [0, 1] are allowed and will extrapolate.

Examples

use deep_time::Position;

let a = Position::new(0.0, 0.0, 0.0);
let b = Position::new(10.0, 20.0, 30.0);

let midpoint = a.lerp(b, 0.5);           // (5.0, 10.0, 15.0)
let quarter   = a.lerp(b, 0.25);         // (2.5, 5.0, 7.5)
let beyond    = a.lerp(b, 1.5);          // (15.0, 30.0, 45.0)

Trait Implementations

impl Clone for Position

fn clone(&self) -> Position

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Position

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Position

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Position

fn eq(&self, other: &Position) -> 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 Serialize for Position

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Tsify for Position

const DECL: &'static str = "/**\n * A 3-dimensional position vector expressed in Cartesian coordinates (x, y, z)\n * with units of meters (SI).\n *\n * This type is designed for high-precision relativistic calculations in space\n * navigation, deep-space tracking, and interplanetary timing. Positions are\n * typically expressed in a heliocentric (Sun-centered) reference frame because\n * the dominant gravitational light-time correction\u{2014}the Shapiro delay\u{2014}is\n * calculated with respect to the Sun.\n */\nexport interface Position {\n x: Real;\n y: Real;\n z: Real;\n}"

const SERIALIZATION_CONFIG: SerializationConfig

type JsType = JsType

fn into_js(&self) -> Result<Self::JsType, Error>

where Self: Serialize,

fn from_js<T>(js: T) -> Result<Self, Error>

where T: Into<JsValue>, Self: DeserializeOwned,

impl Copy for Position

impl StructuralPartialEq for Position