Struct LorentzianTime 

pub struct LorentzianTime { /* private fields */ }

A time model representing Lorentzian (physical) time in relativistic spacetimes.

LorentzianTime corresponds to the real-valued coordinate time used in special and general relativity. It is the standard temporal axis in Minkowski and Lorentzian manifolds with metric signature (− + + +).

This time coordinate governs:

• Causal structure (what can affect what)
• Relativistic dynamics (time dilation, simultaneity)
• Spacetime intervals (light cones, timelike/spacelike separation)

Fields

• id: Unique numeric identifier for this time point
• time_scale: Resolution or unit granularity (e.g., Seconds, Nanoseconds)
• time_unit: Real-valued coordinate time in seconds or specified unit

Example

use deep_causality::{Identifiable, LorentzianTime, Temporal, TimeScale};

let t = LorentzianTime::new(1, TimeScale::Second, std::f64::consts::E);

assert_eq!(t.id(), 1);
assert_eq!(t.time_scale(), TimeScale::Second);

Use Cases

• Relativistic spacetime models (Minkowski, Schwarzschild, FLRW, etc.)
• General relativity simulations and geodesics
• Causal propagation using light cones
• Lorentz-invariant physical systems

Trait Compatibility

• Implements Identifiable via id
• Implements Temporal<f64> via time_unit

Theoretical Background

Coordinate time in Lorentzian geometry appears in the invariant spacetime interval:

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

Unlike Euclidean time (used in QFT), Lorentzian time preserves causal order and reflects real-world physics.

See also

• EuclideanTime for Wick-rotated quantum/statistical domains
• SymbolicTime for logic-based systems

Implementations

impl LorentzianTime

pub fn new(id: u64, time_scale: TimeScale, time_unit: f64) -> Self

Trait Implementations

impl Adjustable<f64> for LorentzianTime

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 LorentzianTime

fn clone(&self) -> LorentzianTime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LorentzianTime

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

Formats the value using the given formatter.

impl Display for LorentzianTime

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

Formats the value using the given formatter.

impl From<LorentzianTime> for TimeKind

fn from(t: LorentzianTime) -> Self

Converts to this type from the input type.

impl Identifiable for LorentzianTime

fn id(&self) -> u64

impl PartialEq for LorentzianTime

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

type Scalar = f64

The scalar value extracted from the input (must implement ScalarValue)

fn project(&self) -> Self::Scalar

Extracts a scalar from self.

impl Temporal<f64> for LorentzianTime

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

impl StructuralPartialEq for LorentzianTime