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).

Used with Velocity and gravitational potentials when building proper-time rates. The caller chooses the reference frame (e.g. Earth-centered or barycentric); this type does not tag the frame.

Fields

x: Real

X-coordinate in meters (SI).

y: Real

Y-coordinate in meters (SI).

z: Real

Z-coordinate in meters (SI).

Implementations

impl Position

pub const ZERO: Self

The zero vector (origin of the chosen coordinate system).

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

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

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

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 (distance from the origin).

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

Straight-line (Euclidean) distance to another position.

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

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 useful when you need an intermediate position along a straight-line segment between two known points.

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::physics::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)

impl Position

pub const WIRE_SIZE: usize = 24

Size of the canonical wire representation in bytes (24 bytes).

pub fn to_wire_bytes(&self) -> [u8; 24]

Serializes this [Position into a fixed 24-byte buffer.

All fields are stored as little-endian IEEE 754 f64.

pub fn from_wire_bytes(bytes: &[u8]) -> Option<Self>

Deserializes a Position from exactly 24 bytes.

Security

Accepts any f64 bit pattern (including NaN/Inf) to match the type’s own invariants. Fixed size makes it immune to length-based attacks. Safe for untrusted input.

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 Copy for Position

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

Equality operator ==.

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

Inequality operator !=.

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 StructuralPartialEq for Position

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 * Used with [`Velocity`](crate::physics::Velocity) and gravitational potentials\n * when building proper-time rates. The caller chooses\n * the reference frame (e.g. Earth-centered or barycentric); this type does not\n * tag the frame.\n */\nexport interface Position {\n /**\n * X-coordinate in meters (SI).\n */\n x: Real;\n /**\n * Y-coordinate in meters (SI).\n */\n y: Real;\n /**\n * Z-coordinate in meters (SI).\n */\n z: Real;\n}"

const SERIALIZATION_CONFIG: SerializationConfig

type JsType = JsType

Must be a type imported through #[wasm_bindgen] extern "C" { .. }. Ts<T> is #[repr(transparent)] over this and passes it across the ABI as a plain JS handle, which any other representation would break.

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,

fn into_ts(&self) -> Result<Ts<Self>, Error>

where Self: Sized + Serialize,

Calls Ts::from_rust on self, returning a Result<Ts<Self>, crate::Error>.