tauZaman | Developers / TemporalDataTypes

This document describes the design of the tauzaman.temporaldatatypes and tauzaman.timestamp packages.

The following sections outline each of the major pieces of the design and give a rationale as to the importance of each. The design has been implemented and is in the public domain.

TimeValue

The TimeValue class is an implementation of a set of primitive operations on time-values from some underlying temporal domain. The domain could be bounded or unbounded, discrete or continuous, etc. The TimeValue class has a minimal set of operations on TimeValues needed to support higher-level, richer semantics. The class permits a complete encapsulation of the domain-dependent code. We implemented a discrete, unbounded domain with two special values (effectively the integers plus Beginning and Ending of Time, the latter two values have special semantics). The domain is unbounded since it uses Java's built-in BigInteger class (which does not limit the size of integers).

Granule

A Granule is the basic unit of Time. A determinate Granule is a TimeValue and a Granularity. An indeterminate Granule is a pair of TimeValues, to represent the lower and upper bounds, and a Granularity. A NowRelativeGranule is a TimeValue, which represents a displacement from now, and a Granularity.

Instant

An Instant is a single Granule. The Granule is anchored to the time-line and represents the distance from the granularity anchor point.

Interval

An Instant is a single Granule.

Semantics

The DeterminateSemantics interface defines a set of basic operations that should be supported by a normal semantics for temporal data types. The IndeterminateSemantics interface defines a set of basic operations for indeterminate data types. The general idea behind the Semantics interface is to abstract the operations on temporal entities. Such operations have a variety of meanings or interpretations. Each implementation of the Semantics interface imbues temporal operations with a different meaning. For example, a Semantics should support an operation that determines whether one instant precedes another. For the purpose of this example, we will assume that an instant is represented as a point on an underlying discrete time-line. Several alternative semantics for this simple operation

LeftOperandSemantics casts the second operand to the granularity of the first operand in all operations. Here is an example using the LeftOperandSemantics.

  Instant i = new Instant("Jan 1, 2002");
  Instant j = new Instant("Jan 2, 2002");
  Interval k = new Interval("1 day");
  // A Semantics is a set of operations
  DeterminateSemantics ops = new LeftOperandSemantics();


  // Compare two instants
  if (ops.precedes(i,j)) {....}


  // Add an interval and an instant
  Instant t = ops.add(i, k);

Note that to change to a different semantics for the operations, all we have to do is change one line, e.g.,

  // Scale to the coarser operands
  DeterminateSemantics ops = new CoarserOperandSemantics();

All the other code remains exactly the same. This design also accommodates Indeterminacy through extension of the IndeterminateSemantics Interface. The IndeterminateSemantics changes boolean operations to use the ExtendedBoolean class (for three-valued logic). It also has operations to set the plausibility and credibility for the Semantics. Using an indeterminate semantics will require minimal contortions for the user.

  Instant i = new Instant("Jan 1, 2002 ~ Jan 4, 2002");
  Instant j = new Instant("Jan 2, 2002 ~ Jan 13, 2002");
  Interval k = new Interval("1 ~ 5 days");
  // An IndeterminateSemantics 
  IndeterminateSemantics ops = new LeftOperandIndeterminateSemantics();


  // Carry out the operations at a plausibility of 60
  ops.setPlausibility(60);


  // Compare two instants
  ExtendedBoolean cond = ops.precedes(i,j);
  if (cond.satisfied()) {...}


  // Add an interval and an instant
  Interval t = ops.add(i, k);

On the user's side, several lines change, one to establish the new semantics, one to set the plausibility, and one to handle ExtendedBoolean values. But the temporal data types remain the same.

ExtendedBoolean

The ExtendedBoolean class encapsulates boolean operations on some underlying multi-valued domain. It currently implements a 3-valued domain.