Struct LorentzianSpacetime 

pub struct LorentzianSpacetime { /* private fields */ }

A 4-dimensional spacetime context based on Lorentzian geometry, as used in General Relativity.

LorentzianSpacetime encodes events in a curved or flat spacetime using the Minkowski metric signature (−+++). This allows meaningful distinction between time-like, space-like, and light-like intervals:

• s² < 0: time-like separation
• s² = 0: light-like (null) separation
• s² > 0: space-like separation

The default implementation assumes flat spacetime (no curvature), suitable for special relativity. For curved general relativistic spacetime, a metric tensor can be added later.

Fields

• id: Unique numeric identifier
• x: X-coordinate in meters
• y: Y-coordinate in meters
• z: Z-coordinate in meters
• t: time (e.g., seconds)
• time_scale: Time scale unit (e.g., seconds, milliseconds)

Coordinate Index Mapping

/// When used with the Coordinate trait, the following index mapping applies:

• 0 => x
• 1 => y
• 2 => z
• 3 => t

Minkowski interval (squared):

s² = -c²·t² + x² + y² + z²

Notes

• The time coordinate is not just a timestamp — it has physical meaning (e.g., proper time)
• The sign convention is configurable (−+++) or (+−−−), but we assume (−+++) by default
• Units must be consistent (e.g., all in SI)

Example

use deep_causality::*;

let s1 = LorentzianSpacetime::new(1, 1.0, 0.0, 0.0, 0.0, TimeScale::Second);
let s2 = LorentzianSpacetime::new(2, 2.0, 3.0, 4.0, 0.0, TimeScale::Second);

let interval = s1.interval_squared(&s2);
println!("Minkowski interval²: {interval}");

Implementations

impl LorentzianSpacetime

pub fn x(&self) -> f64

pub fn y(&self) -> f64

pub fn z(&self) -> f64

impl LorentzianSpacetime

pub fn new( id: u64, x: f64, y: f64, z: f64, t: f64, time_scale: TimeScale, ) -> Self

Trait Implementations

impl Adjustable<f64> for LorentzianSpacetime

fn update<const W: usize, const H: usize, const D: usize, const C: usize>( &mut self, array_grid: &ArrayGrid<f64, W, H, D, C>, ) -> Result<(), UpdateError>

The default implementation does nothing to keep update optional. Override this method to implement a node update when needed. For a sample implementation, see src/types/context_types/node_types_adjustable

fn adjust<const W: usize, const H: usize, const D: usize, const C: usize>( &mut self, array_grid: &ArrayGrid<f64, W, H, D, C>, ) -> Result<(), AdjustmentError>

The default implementation does nothing to keep adjustment optional. Override this method to implement a node adjustment when needed. Depending on the type of node adjustment, select a 1, 2,3, or 4 dimensional array grid that contains the transformation data to apply to the node. For a sample implementation, see src/types/context_types/node_types_adjustable

impl Clone for LorentzianSpacetime

fn clone(&self) -> LorentzianSpacetime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Coordinate<f64> for LorentzianSpacetime

fn dimension(&self) -> usize

Returns the number of dimensions in the coordinate system (always 4).l

fn coordinate(&self, index: usize) -> Result<&f64, IndexError>

Returns a reference to the coordinate value at the specified index.

Index Mapping

• 0 => x
• 1 => y
• 2 => z
• 3 => t

Errors

Returns IndexError if the index is out of bounds.

impl Debug for LorentzianSpacetime

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

Formats the value using the given formatter.

impl Display for LorentzianSpacetime

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

Formats the value using the given formatter.

impl Identifiable for LorentzianSpacetime

fn id(&self) -> u64

impl PartialEq for LorentzianSpacetime

fn eq(&self, other: &LorentzianSpacetime) -> 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 SpaceTemporal<f64, f64> for LorentzianSpacetime

fn t(&self) -> &f64

Returns the value associated with the temporal (4th) dimension.

impl SpaceTemporalInterval for LorentzianSpacetime

fn time(&self) -> f64

Returns the time coordinate in seconds.

fn position(&self) -> [f64; 3]

Returns the spatial coordinates [x, y, z] in meters.

fn interval_squared(&self, other: &Self) -> f64

Computes the squared Minkowski interval between self and other.

impl Temporal<f64> for LorentzianSpacetime

fn time_scale(&self) -> TimeScale

Returns the unit scale of time (e.g. TimeScale::Milliseconds).

fn time_unit(&self) -> f64

Returns a reference to the numeric time unit (e.g. 0, 100, 32768).

impl Spatial<f64> for LorentzianSpacetime

impl StructuralPartialEq for LorentzianSpacetime