TimeUnit (DJUNITS 3.01.00 API)

java.lang.Object
- org.djunits.unit.Unit<U>
- - org.djunits.unit.LinearUnit<AU>
  - - org.djunits.unit.AbsoluteLinearUnit<TimeUnit,DurationUnit>
    - - org.djunits.unit.TimeUnit

All Implemented Interfaces:

Serializable, AbsoluteUnit
```
public class TimeUnit
extends AbsoluteLinearUnit<TimeUnit,DurationUnit>
```
Standard absolute time units. Note that when the offset of a stored absolute Time becomes large, precision of a float or double might not be enough for the required resolution of a Time. A float has around 7 significant digits (23 bit mantissa), whereas a double has around 16 significant digits (52 bit mantissa). This means that when we need to have a float time that is precise to microseconds, the Time value should not go above 2^22 = 4.0E6. This is not enough to store Epoch values! So feeding System.TimeInMillis() to a FloatTime with TimeUnit.BASE as its unit is not having the required precision. For a (double) Time with TimeUnit.BASE as its unit, the largest value where the ms precision is reached is 2^51 = 2.3E15, which is around 71000 years. This is sufficient to store a date on an Epoch level precise to a ms.
Copyright (c) 2015-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
BSD-style license. See DJUNITS License.
$LastChangedDate: 2019-03-02 19:06:46 +0100 (Sat, 02 Mar 2019) $, @version $Revision: 342 $, by $Author: averbraeck $, initial version May 15, 2014

Author:

Alexander Verbraeck

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static TimeUnit`	`BASE` The base unit for time with an artifical "zero" point.
`static TimeUnit`	`BASE_DAY` The base unit for time with an artifical "zero" point with a calculation in days.
`static TimeUnit`	`BASE_HOUR` The base unit for time with an artifical "zero" point with a calculation in hours.
`static TimeUnit`	`BASE_MICROSECOND` The base unit for time with an artifical "zero" point with a calculation in microseconds.
`static TimeUnit`	`BASE_MILLISECOND` The base unit for time with an artifical "zero" point with a calculation in milliseconds.
`static TimeUnit`	`BASE_MINUTE` The base unit for time with an artifical "zero" point with a calculation in minutes.
`static TimeUnit`	`BASE_SECOND` The base unit for time with an artifical "zero" point with a calculation in seconds.
`static TimeUnit`	`BASE_WEEK` The base unit for time with an artifical "zero" point with a calculation in weeks.
`static TimeUnit`	`EPOCH` The POSIX and Gregorian Epoch: January 1, 1970 at 00:00 UTC with a calculation in seconds.
`static TimeUnit`	`EPOCH_DAY` The POSIX and Gregorian Epoch: January 1, 1970 at 00:00 UTC with a calculation in days.
`static TimeUnit`	`EPOCH_HOUR` The POSIX and Gregorian Epoch: January 1, 1970 at 00:00 UTC with a calculation in hours.
`static TimeUnit`	`EPOCH_J2000_1` The Epoch with J2000.0 as the origin, which is The Gregorian date January 1, 2000 at 12:00 GMT (noon) with a calculation in seconds.
`static TimeUnit`	`EPOCH_MICROSECOND` The POSIX and Gregorian Epoch: January 1, 1970 at 00:00 UTC with a calculation in microseconds.
`static TimeUnit`	`EPOCH_MILLISECOND` The POSIX and Gregorian Epoch: January 1, 1970 at 00:00 UTC with a calculation in milliseconds.
`static TimeUnit`	`EPOCH_MINUTE` The POSIX and Gregorian Epoch: January 1, 1970 at 00:00 UTC with a calculation in minutes.
`static TimeUnit`	`EPOCH_SECOND` The POSIX and Gregorian Epoch: January 1, 1970 at 00:00 UTC with a calculation in seconds.
`static TimeUnit`	`EPOCH_WEEK` The POSIX and Gregorian Epoch: January 1, 1970 at 00:00 UTC with a calculation in weeks.
`static TimeUnit`	`EPOCH_YEAR_1` The Epoch with 0001-01-01 AD at 00:00 as the origin with a calculation in seconds.

Fields inherited from class org.djunits.unit.Unit
STANDARD_UNITS

Constructor Summary

Constructors
Constructor and Description
`TimeUnit(String name, String abbreviation, UnitSystem unitSystem, double scaleFactor, double offset, DurationUnit relativeUnit)` Build a user-defined TimeUnit with a scale factor and offset to the base TimeUnit.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type Method and Description

String getSICoefficientsString()

TimeUnit getStandardUnit()
- Methods inherited from class org.djunits.unit.AbsoluteLinearUnit
  equals, equalsIgnoreNaming, getOffset, getRelativeUnit, getScale, hashCode
- Methods inherited from class org.djunits.unit.LinearUnit
  getScaleFactor
- Methods inherited from class org.djunits.unit.Unit
  generateHashCode, getAbbreviation, getAbbreviationKey, getAllUnitsOfThisType, getDefaultLocaleAbbreviation, getDefaultLocaleName, getDefaultLocaleTextualRepresentation, getDefaultLocaleTextualRepresentations, getDefaultTextualRepresentation, getName, getSICoefficients, getTextualRepresentations, getUnits, getUnitSystem, isBaseSIUnit, isLocalizable, lookupOrCreateSIUnitWithSICoefficients, lookupOrCreateUnitWithSICoefficients, lookupUnitWithSICoefficients, toString
- Methods inherited from class java.lang.Object
  clone, finalize, getClass, notify, notifyAll, wait, wait, wait
- Methods inherited from interface org.djunits.unit.AbsoluteUnit
  getScaleFactor

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`String`	`getSICoefficientsString()`
`TimeUnit`	`getStandardUnit()`

- Field Detail
  - BASE
```
public static final TimeUnit BASE
```
    The base unit for time with an artifical "zero" point.
  - BASE_SECOND
```
public static final TimeUnit BASE_SECOND
```
    The base unit for time with an artifical "zero" point with a calculation in seconds. Note that when the offset becomes large, precision of a float or double might not be enough for the required resolution of a Time. A float has around 7 significant digits (23 bit mantissa), whereas a double has around 16 significant digits (52 bit mantissa). This means that when we need to have a float time that is precise to microseconds, the Time value should not go above 2^22 = 4.0E6. This is not enough to store Epoch values! So feeding System.TimeInMillis() to a FloatTime with TimeUnit.BASE as its unit is not having the required precision. For a (double) Time with TimeUnit.BASE as its unit, the largest value where the ms precision is reached is 2^51 = 2.3E15, which is around 71000 years. This is sufficient to store a date on an Epoch level precise to a ms.
  - BASE_MICROSECOND
```
public static final TimeUnit BASE_MICROSECOND
```
    The base unit for time with an artifical "zero" point with a calculation in microseconds.
  - BASE_MILLISECOND
```
public static final TimeUnit BASE_MILLISECOND
```
    The base unit for time with an artifical "zero" point with a calculation in milliseconds.
  - BASE_MINUTE
```
public static final TimeUnit BASE_MINUTE
```
    The base unit for time with an artifical "zero" point with a calculation in minutes.
  - BASE_HOUR
```
public static final TimeUnit BASE_HOUR
```
    The base unit for time with an artifical "zero" point with a calculation in hours.
  - BASE_DAY
```
public static final TimeUnit BASE_DAY
```
    The base unit for time with an artifical "zero" point with a calculation in days.
  - BASE_WEEK
```
public static final TimeUnit BASE_WEEK
```
    The base unit for time with an artifical "zero" point with a calculation in weeks.
  - EPOCH
```
public static final TimeUnit EPOCH
```
    The POSIX and Gregorian Epoch: January 1, 1970 at 00:00 UTC with a calculation in seconds. The base should be taken in such a way that a resolution of a millisecond is still 'visible' on a date in, say, 2020. When 1-1-1970 is used as the origin, 1-1-2020 has a value of 1,577,836,800,000 milliseconds = 1.6E12 ms. If we want to be precise on the ms level, we need 12 significant digits. A float has around 7 significant digits (23 bit mantissa), whereas a double has around 16 significant digits (52 bit mantissa). This means that a float time with an offset of 1-1-1970 is at best precise to a minute level. A double time is precise to microseconds. Therefore, avoid using float times that use the EPOCH.
  - EPOCH_SECOND
```
public static final TimeUnit EPOCH_SECOND
```
    The POSIX and Gregorian Epoch: January 1, 1970 at 00:00 UTC with a calculation in seconds.
  - EPOCH_MICROSECOND
```
public static final TimeUnit EPOCH_MICROSECOND
```
    The POSIX and Gregorian Epoch: January 1, 1970 at 00:00 UTC with a calculation in microseconds.
  - EPOCH_MILLISECOND
```
public static final TimeUnit EPOCH_MILLISECOND
```
    The POSIX and Gregorian Epoch: January 1, 1970 at 00:00 UTC with a calculation in milliseconds.
  - EPOCH_MINUTE
```
public static final TimeUnit EPOCH_MINUTE
```
    The POSIX and Gregorian Epoch: January 1, 1970 at 00:00 UTC with a calculation in minutes.
  - EPOCH_HOUR
```
public static final TimeUnit EPOCH_HOUR
```
    The POSIX and Gregorian Epoch: January 1, 1970 at 00:00 UTC with a calculation in hours.
  - EPOCH_DAY
```
public static final TimeUnit EPOCH_DAY
```
    The POSIX and Gregorian Epoch: January 1, 1970 at 00:00 UTC with a calculation in days.
  - EPOCH_WEEK
```
public static final TimeUnit EPOCH_WEEK
```
    The POSIX and Gregorian Epoch: January 1, 1970 at 00:00 UTC with a calculation in weeks.
  - EPOCH_YEAR_1
```
public static final TimeUnit EPOCH_YEAR_1
```
    The Epoch with 0001-01-01 AD at 00:00 as the origin with a calculation in seconds. When 1-1-0001 is used as the origin, 1-1-2020 has a value of around 6.4E13 ms. If we want to be precise on the ms level, we need 13 significant digits. A float has around 7 significant digits (23 bit mantissa), whereas a double has around 16 significant digits (52 bit mantissa). This means that a float time with an offset of 1-1-0001 is at best precise to an hour level. A double time is precise to microseconds. Therefore, avoid using float times that use the EPOCH_YEAR_1.
  - EPOCH_J2000_1
```
public static final TimeUnit EPOCH_J2000_1
```
    The Epoch with J2000.0 as the origin, which is The Gregorian date January 1, 2000 at 12:00 GMT (noon) with a calculation in seconds. When 1-1-2000 is used as the origin, 1-1-2020 has a value of around 6.3E11 ms. If we want to be precise on the ms level, we need 11 significant digits. A float has around 7 significant digits (23 bit mantissa), whereas a double has around 16 significant digits (52 bit mantissa). This means that a float time with an offset of 1-1-2000 is at best precise to a minute level. A double time is precise to fractions of microseconds. Therefore, avoid using float times that use the EPOCH_J2000_1.
- Constructor Detail
  - TimeUnit
```
public TimeUnit(String name,
                String abbreviation,
                UnitSystem unitSystem,
                double scaleFactor,
                double offset,
                DurationUnit relativeUnit)
```
    Build a user-defined TimeUnit with a scale factor and offset to the base TimeUnit.
    
    Parameters:
    
    name - String; the long name of the unit
    
    abbreviation - String; the abbreviation of the unit
    
    unitSystem - UnitSystem; the unit system, e.g. SI or Imperial
    
    scaleFactor - double; multiply a value in this unit by the factor to convert to the given reference unit
    
    offset - double; the offset to the reference unit to add to convert to the standard (e.g., BASE) unit
    
    relativeUnit - DurationUnit; the corresponding relative unit belonging to this absolute unit
- Method Detail
  - getStandardUnit
```
public final TimeUnit getStandardUnit()
```
    Specified by:
    
    getStandardUnit in class Unit<TimeUnit>
    
    Returns:
    
    the SI standard unit for this unit, or the de facto standard unit if SI is not available
  - getSICoefficientsString
```
public final String getSICoefficientsString()
```
    Specified by:
    
    getSICoefficientsString in class Unit<TimeUnit>
    
    Returns:
    
    the SI standard coefficients for this unit, e.g., kgm/s2 or m-2s2A or m^-2.s^2.A or m^-2s^2A (not necessarily normalized)

Class TimeUnit

Field Summary

Fields inherited from class org.djunits.unit.Unit

Constructor Summary

Method Summary

Methods inherited from class org.djunits.unit.AbsoluteLinearUnit

Methods inherited from class org.djunits.unit.LinearUnit

Methods inherited from class org.djunits.unit.Unit

Methods inherited from class java.lang.Object

Methods inherited from interface org.djunits.unit.AbsoluteUnit

Field Detail

BASE

BASE_SECOND

BASE_MICROSECOND

BASE_MILLISECOND

BASE_MINUTE

BASE_HOUR

BASE_DAY

BASE_WEEK

EPOCH

EPOCH_SECOND

EPOCH_MICROSECOND

EPOCH_MILLISECOND

EPOCH_MINUTE

EPOCH_HOUR

EPOCH_DAY

EPOCH_WEEK

EPOCH_YEAR_1

EPOCH_J2000_1

Constructor Detail

TimeUnit

Method Detail

getStandardUnit

getSICoefficientsString