Struct DiscreteTime 

pub struct DiscreteTime { /* private fields */ }

A time model representing discrete, uniformly spaced ticks instead of continuous physical time.

DiscreteTime is designed for systems that evolve in fixed increments, such as:

• Simulation steps
• Control loops
• State machines
• Reinforcement learning environments
• Event-driven or digital logic systems

This model is ideal when:

• You don’t need wall-clock time or sub-second resolution
• You care only about the order and progression of steps
• Time is measured in counted ticks or iterations

Fields

• id: Unique numeric identifier for the time point
• tick_scale: Scale of the tick (e.g., Milliseconds, Microseconds, Seconds)
• tick_unit: The current tick index (u64), typically monotonically increasing

Examples

use deep_causality::{DiscreteTime, Temporal, TimeScale};

let t0 = DiscreteTime::new(1, TimeScale::Microseconds, 0);
let t1 = DiscreteTime::new(2, TimeScale::Microseconds, 1);

assert!(t0.time_unit() < t1.time_unit());
assert_eq!(t0.time_scale(), TimeScale::Microseconds);

Trait Compatibility

• Implements Identifiable via id
• Implements Temporal<u64>, so it can be used in any time-aware causal context

Use Cases

• Agent-based simulations with fixed timesteps
• Ticking state machines (e.g., embedded control)
• Digital logic simulation
• Environments where temporal resolution is implicit or constant

Note

While tick_unit is a u64 and ordered, it does not imply any physical duration unless paired with a meaningful TimeScale. The interpretation of ticks is context-dependent.

See also

• SymbolicTime for non-numeric symbolic events
• LorentzianTime or ProperTime for physical time

Implementations

impl DiscreteTime

pub fn new(id: u64, tick_scale: TimeScale, tick_unit: u64) -> Self

Trait Implementations

impl Adjustable<u64> for DiscreteTime

fn update<const W: usize, const H: usize, const D: usize, const C: usize>( &mut self, array_grid: &ArrayGrid<u64, 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<u64, 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 DiscreteTime

fn clone(&self) -> DiscreteTime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DiscreteTime

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

Formats the value using the given formatter.

impl Display for DiscreteTime

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

Formats the value using the given formatter.

impl From<DiscreteTime> for TimeKind

fn from(t: DiscreteTime) -> Self

Converts to this type from the input type.

impl Hash for DiscreteTime

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 Identifiable for DiscreteTime

fn id(&self) -> u64

impl PartialEq for DiscreteTime

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

type Scalar = u64

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

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

Extracts a scalar from self.

impl Temporal<u64> for DiscreteTime

fn time_scale(&self) -> TimeScale

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

fn time_unit(&self) -> u64

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

impl Copy for DiscreteTime

impl Eq for DiscreteTime

impl StructuralPartialEq for DiscreteTime