java.lang.Object
- org.orekit.time.FieldAbsoluteDate<T>

All Implemented Interfaces:

Comparable<FieldAbsoluteDate<T>>, FieldTimeStamped<T>, TimeShiftable<FieldAbsoluteDate<T>>
```
public class FieldAbsoluteDate<T extends org.hipparchus.RealFieldElement<T>>
extends Object
implements FieldTimeStamped<T>, TimeShiftable<FieldAbsoluteDate<T>>, Comparable<FieldAbsoluteDate<T>>
```
This class represents a specific instant in time.
Instances of this class are considered to be absolute in the sense that each one represent the occurrence of some event and can be compared to other instances or located in any time scale. In other words the different locations of an event with respect to two different time scales (say TAI and UTC for example) are simply different perspective related to a single object. Only one FieldAbsoluteDate instance is needed, both representations being available from this single instance by specifying the time scales as parameter when calling the ad-hoc methods.

Since an instance is not bound to a specific time-scale, all methods related to the location of the date within some time scale require to provide the time scale as an argument. It is therefore possible to define a date in one time scale and to use it in another one. An example of such use is to read a date from a file in UTC and write it in another file in TAI. This can be done as follows:
```
   DateTimeComponents utcComponents = readNextDate();
   FieldAbsoluteDate<T> date = new FieldAbsoluteDate<>(utcComponents, TimeScalesFactory.getUTC());
   writeNextDate(date.getComponents(TimeScalesFactory.getTAI()));
 
```
Two complementary views are available:
- location view (mainly for input/output or conversions)
  
  locations represent the coordinate of one event with respect to a time scale. The related methods are FieldAbsoluteDate(Field, DateComponents, TimeComponents, TimeScale), FieldAbsoluteDate(Field, int, int, int, int, int, double, TimeScale), FieldAbsoluteDate(Field, int, int, int, TimeScale), FieldAbsoluteDate(Field, Date, TimeScale), createGPSDate(int, RealFieldElement), parseCCSDSCalendarSegmentedTimeCode(byte, byte[]), toString()toDate(TimeScale), toString(timeScale), toString(), and timeScalesOffset(org.orekit.time.TimeScale, org.orekit.time.TimeScale).
- offset view (mainly for physical computation)
  
  offsets represent either the flow of time between two events (two instances of the class) or durations. They are counted in seconds, are continuous and could be measured using only a virtually perfect stopwatch. The related methods are FieldAbsoluteDate(FieldAbsoluteDate, double), parseCCSDSUnsegmentedTimeCode(Field, byte, byte, byte[], FieldAbsoluteDate), parseCCSDSDaySegmentedTimeCode(Field, byte, byte[], DateComponents), durationFrom(FieldAbsoluteDate), compareTo(FieldAbsoluteDate), equals(Object) and hashCode().
A few reference epochs which are commonly used in space systems have been defined. These epochs can be used as the basis for offset computation. The supported epochs are: getJulianEpoch(Field), getModifiedJulianEpoch(Field), getFiftiesEpoch(Field), getCCSDSEpoch(Field), getGalileoEpoch(Field), getGPSEpoch(Field), getJ2000Epoch(Field), getJavaEpoch(Field). There are also two factory methods createJulianEpoch(RealFieldElement) and createBesselianEpoch(RealFieldElement) that can be used to compute other reference epochs like J1900.0 or B1950.0. In addition to these reference epochs, two other constants are defined for convenience: getPastInfinity(Field) and getFutureInfinity(Field), which can be used either as dummy dates when a date is not yet initialized, or for initialization of loops searching for a min or max date.

Instances of the FieldAbsoluteDate class are guaranteed to be immutable.
Author:

Luc Maisonobe

See Also:

TimeScale, TimeStamped, ChronologicalComparator

Constructor Summary

Constructors
Constructor	Description
`FieldAbsoluteDate(org.hipparchus.Field<T> field)`	Create an instance with a default value (`getJ2000Epoch(Field)`).
`FieldAbsoluteDate(org.hipparchus.Field<T> field, int year, int month, int day, int hour, int minute, double second, TimeScale timeScale)`	Build an instance from a location in a `time scale`.
`FieldAbsoluteDate(org.hipparchus.Field<T> field, int year, int month, int day, TimeScale timeScale)`	Build an instance from a location in a `time scale`.
`FieldAbsoluteDate(org.hipparchus.Field<T> field, int year, Month month, int day, int hour, int minute, double second, TimeScale timeScale)`	Build an instance from a location in a `time scale`.
`FieldAbsoluteDate(org.hipparchus.Field<T> field, int year, Month month, int day, TimeScale timeScale)`	Build an instance from a location in a `time scale`.
`FieldAbsoluteDate(org.hipparchus.Field<T> field, String location, TimeScale timeScale)`	Build an instance from a location (parsed from a string) in a `time scale`.
`FieldAbsoluteDate(org.hipparchus.Field<T> field, Date location, TimeScale timeScale)`	Build an instance from a location in a `time scale`.
`FieldAbsoluteDate(org.hipparchus.Field<T> field, AbsoluteDate date)`	Build an instance from an AbsoluteDate.
`FieldAbsoluteDate(org.hipparchus.Field<T> field, DateComponents date, TimeComponents time, TimeScale timeScale)`	Build an instance from a location in a `time scale`.
`FieldAbsoluteDate(org.hipparchus.Field<T> field, DateComponents date, TimeScale timeScale)`	Build an instance from a location in a `time scale`.
`FieldAbsoluteDate(org.hipparchus.Field<T> field, DateTimeComponents location, TimeScale timeScale)`	Build an instance from a location in a `time scale`.
`FieldAbsoluteDate(AbsoluteDate since, T elapsedDuration)`	Build an instance from an elapsed duration since to another instant.
`FieldAbsoluteDate(FieldAbsoluteDate<T> since, double elapsedDuration)`	Build an instance from an elapsed duration since to another instant.
`FieldAbsoluteDate(FieldAbsoluteDate<T> reference, double apparentOffset, TimeScale timeScale)`	Build an instance from an apparent clock offset with respect to another instant in the perspective of a specific `time scale`.
`FieldAbsoluteDate(FieldAbsoluteDate<T> since, T elapsedDuration)`	Build an instance from an elapsed duration since to another instant.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`int`	`compareTo(FieldAbsoluteDate<T> date)`	Compare the instance with another date.
`static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T>`	`createBesselianEpoch(T besselianEpoch)`	Build an instance corresponding to a Besselian Epoch (BE).
`static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T>`	`createGPSDate(int weekNumber, T milliInWeek)`	Build an instance corresponding to a GPS date.
`static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T>`	`createJDDate(int jd, T secondsSinceNoon, TimeScale timeScale)`	Build an instance corresponding to a Julian Day date.
`static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T>`	`createJulianEpoch(T julianEpoch)`	Build an instance corresponding to a Julian Epoch (JE).
`static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T>`	`createMJDDate(int mjd, T secondsInDay, TimeScale timeScale)`	Build an instance corresponding to a Modified Julian Day date.
`T`	`durationFrom(AbsoluteDate instant)`	Compute the physically elapsed duration between two instants.
`T`	`durationFrom(FieldAbsoluteDate<T> instant)`	Compute the physically elapsed duration between two instants.
`boolean`	`equals(Object date)`	Check if the instance represent the same time as another instance.
`static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T>`	`getCCSDSEpoch(org.hipparchus.Field<T> field)`	Reference epoch for CCSDS Time Code Format (CCSDS 301.0-B-4): 1958-01-01T00:00:00 International Atomic Time (not UTC).
`DateTimeComponents`	`getComponents(int minutesFromUTC)`	Split the instance into date/time components for a local time.
`DateTimeComponents`	`getComponents(TimeZone timeZone)`	Split the instance into date/time components for a time zone.
`DateTimeComponents`	`getComponents(TimeScale timeScale)`	Split the instance into date/time components.
`FieldAbsoluteDate<T>`	`getDate()`	Get the date.
`org.hipparchus.Field<T>`	`getField()`	Get the field.
`static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T>`	`getFiftiesEpoch(org.hipparchus.Field<T> field)`	Reference epoch for 1950 dates: 1950-01-01T00:00:00 Terrestrial Time.
`static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T>`	`getFutureInfinity(org.hipparchus.Field<T> field)`	Dummy date at infinity in the future direction.
`static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T>`	`getGalileoEpoch(org.hipparchus.Field<T> field)`	Reference epoch for Galileo System Time: 1999-08-22T00:00:00 UTC.
`static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T>`	`getGPSEpoch(org.hipparchus.Field<T> field)`	Reference epoch for GPS weeks: 1980-01-06T00:00:00 GPS time.
`static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T>`	`getJ2000Epoch(org.hipparchus.Field<T> field)`	J2000.0 Reference epoch: 2000-01-01T12:00:00 Terrestrial Time (not UTC).
`static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T>`	`getJavaEpoch(org.hipparchus.Field<T> field)`	Java Reference epoch: 1970-01-01T00:00:00 Universal Time Coordinate.
`static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T>`	`getJulianEpoch(org.hipparchus.Field<T> field)`	Reference epoch for julian dates: -4712-01-01T12:00:00 Terrestrial Time.
`static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T>`	`getModifiedJulianEpoch(org.hipparchus.Field<T> field)`	Reference epoch for modified julian dates: 1858-11-17T00:00:00 Terrestrial Time.
`static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T>`	`getPastInfinity(org.hipparchus.Field<T> field)`	Dummy date at infinity in the past direction.
`int`	`hashCode()`	Get a hashcode for this date.
`T`	`offsetFrom(FieldAbsoluteDate<T> instant, TimeScale timeScale)`	Compute the apparent clock offset between two instant in the perspective of a specific `time scale`.
`FieldAbsoluteDate<T>`	`parseCCSDSCalendarSegmentedTimeCode(byte preambleField, byte[] timeField)`	Build an instance from a CCSDS Calendar Segmented Time Code (CCS).
`static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T>`	`parseCCSDSDaySegmentedTimeCode(org.hipparchus.Field<T> field, byte preambleField, byte[] timeField, DateComponents agencyDefinedEpoch)`	Build an instance from a CCSDS Day Segmented Time Code (CDS).
`static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T>`	`parseCCSDSUnsegmentedTimeCode(org.hipparchus.Field<T> field, byte preambleField1, byte preambleField2, byte[] timeField, FieldAbsoluteDate<T> agencyDefinedEpoch)`	Build an instance from a CCSDS Unsegmented Time Code (CUC).
`FieldAbsoluteDate<T>`	`shiftedBy(double dt)`	Get a time-shifted date.
`FieldAbsoluteDate<T>`	`shiftedBy(T dt)`	Get a time-shifted date.
`T`	`timeScalesOffset(TimeScale scale1, TimeScale scale2)`	Compute the offset between two time scales at the current instant.
`AbsoluteDate`	`toAbsoluteDate()`	Transform the FieldAbsoluteDate in an AbsoluteDate.
`Date`	`toDate(TimeScale timeScale)`	Convert the instance to a Java `Date`.
`String`	`toString()`	Get a String representation of the instant location in UTC time scale.
`String`	`toString(int minutesFromUTC)`	Get a String representation of the instant location for a local time.
`String`	`toString(TimeZone timeZone)`	Get a String representation of the instant location for a time zone.
`String`	`toString(TimeScale timeScale)`	Get a String representation of the instant location.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         AbsoluteDate date)
```
    Build an instance from an AbsoluteDate.
    
    Parameters:
    
    field - used by default
    
    date - AbsoluteDate to instantiate as a FieldAbsoluteDate
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field)
```
    Create an instance with a default value (getJ2000Epoch(Field)).
    
    Parameters:
    
    field - field used by default
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(FieldAbsoluteDate<T> since,
                         T elapsedDuration)
```
    Build an instance from an elapsed duration since to another instant.
    It is important to note that the elapsed duration is not the difference between two readings on a time scale. As an example, the duration between the two instants leading to the readings 2005-12-31T23:59:59 and 2006-01-01T00:00:00 in the UTC time scale is not 1 second, but a stop watch would have measured an elapsed duration of 2 seconds between these two instances because a leap second was introduced at the end of 2005 in this time scale.
    
    This constructor is the reverse of the durationFrom(FieldAbsoluteDate) method.
    
    Parameters:
    
    since - start instant of the measured duration
    
    elapsedDuration - physically elapsed duration from the since instant, as measured in a regular time scale
    
    See Also:
    
    durationFrom(FieldAbsoluteDate)
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         String location,
                         TimeScale timeScale)
```
    Build an instance from a location (parsed from a string) in a time scale.
    The supported formats for location are mainly the ones defined in ISO-8601 standard, the exact subset is explained in DateTimeComponents.parseDateTime(String), DateComponents.parseDate(String) and TimeComponents.parseTime(String).
    
    As CCSDS ASCII calendar segmented time code is a trimmed down version of ISO-8601, it is also supported by this constructor.
    
    Parameters:
    
    field - field utilized by default
    
    location - location in the time scale, must be in a supported format
    
    timeScale - time scale
    
    Throws:
    
    IllegalArgumentException - if location string is not in a supported format
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         DateTimeComponents location,
                         TimeScale timeScale)
```
    Build an instance from a location in a time scale.
    
    Parameters:
    
    field - field utilized by default
    
    location - location in the time scale
    
    timeScale - time scale
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         DateComponents date,
                         TimeComponents time,
                         TimeScale timeScale)
```
    Build an instance from a location in a time scale.
    
    Parameters:
    
    field - field utilized by default
    
    date - date location in the time scale
    
    time - time location in the time scale
    
    timeScale - time scale
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         int year,
                         int month,
                         int day,
                         int hour,
                         int minute,
                         double second,
                         TimeScale timeScale)
                  throws IllegalArgumentException
```
    Build an instance from a location in a time scale.
    
    Parameters:
    
    field - field utilized by default
    
    year - year number (may be 0 or negative for BC years)
    
    month - month number from 1 to 12
    
    day - day number from 1 to 31
    
    hour - hour number from 0 to 23
    
    minute - minute number from 0 to 59
    
    second - second number from 0.0 to 60.0 (excluded)
    
    timeScale - time scale
    
    Throws:
    
    IllegalArgumentException - if inconsistent arguments are given (parameters out of range)
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         int year,
                         Month month,
                         int day,
                         int hour,
                         int minute,
                         double second,
                         TimeScale timeScale)
                  throws IllegalArgumentException
```
    Build an instance from a location in a time scale.
    
    Parameters:
    
    field - field utilized by default
    
    year - year number (may be 0 or negative for BC years)
    
    month - month enumerate
    
    day - day number from 1 to 31
    
    hour - hour number from 0 to 23
    
    minute - minute number from 0 to 59
    
    second - second number from 0.0 to 60.0 (excluded)
    
    timeScale - time scale
    
    Throws:
    
    IllegalArgumentException - if inconsistent arguments are given (parameters out of range)
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         DateComponents date,
                         TimeScale timeScale)
                  throws IllegalArgumentException
```
    Build an instance from a location in a time scale.
    The hour is set to 00:00:00.000.
    
    Parameters:
    
    field - field utilized by default
    
    date - date location in the time scale
    
    timeScale - time scale
    
    Throws:
    
    IllegalArgumentException - if inconsistent arguments are given (parameters out of range)
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         int year,
                         int month,
                         int day,
                         TimeScale timeScale)
                  throws IllegalArgumentException
```
    Build an instance from a location in a time scale.
    The hour is set to 00:00:00.000.
    
    Parameters:
    
    field - field utilized by default
    
    year - year number (may be 0 or negative for BC years)
    
    month - month number from 1 to 12
    
    day - day number from 1 to 31
    
    timeScale - time scale
    
    Throws:
    
    IllegalArgumentException - if inconsistent arguments are given (parameters out of range)
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         int year,
                         Month month,
                         int day,
                         TimeScale timeScale)
                  throws IllegalArgumentException
```
    Build an instance from a location in a time scale.
    The hour is set to 00:00:00.000.
    
    Parameters:
    
    field - field utilized by default
    
    year - year number (may be 0 or negative for BC years)
    
    month - month enumerate
    
    day - day number from 1 to 31
    
    timeScale - time scale
    
    Throws:
    
    IllegalArgumentException - if inconsistent arguments are given (parameters out of range)
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(org.hipparchus.Field<T> field,
                         Date location,
                         TimeScale timeScale)
```
    Build an instance from a location in a time scale.
    
    Parameters:
    
    field - field utilized as default
    
    location - location in the time scale
    
    timeScale - time scale
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(FieldAbsoluteDate<T> since,
                         double elapsedDuration)
```
    Build an instance from an elapsed duration since to another instant.
    It is important to note that the elapsed duration is not the difference between two readings on a time scale.
    
    Parameters:
    
    since - start instant of the measured duration
    
    elapsedDuration - physically elapsed duration from the since instant, as measured in a regular time scale
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(AbsoluteDate since,
                         T elapsedDuration)
```
    Build an instance from an elapsed duration since to another instant.
    It is important to note that the elapsed duration is not the difference between two readings on a time scale.
    
    Parameters:
    
    since - start instant of the measured duration
    
    elapsedDuration - physically elapsed duration from the since instant, as measured in a regular time scale
  - FieldAbsoluteDate
```
public FieldAbsoluteDate(FieldAbsoluteDate<T> reference,
                         double apparentOffset,
                         TimeScale timeScale)
```
    Build an instance from an apparent clock offset with respect to another instant in the perspective of a specific time scale.
    It is important to note that the apparent clock offset is the difference between two readings on a time scale and not an elapsed duration. As an example, the apparent clock offset between the two instants leading to the readings 2005-12-31T23:59:59 and 2006-01-01T00:00:00 in the UTC time scale is 1 second, but the elapsed duration is 2 seconds because a leap second has been introduced at the end of 2005 in this time scale.
    
    This constructor is the reverse of the offsetFrom(FieldAbsoluteDate, TimeScale) method.
    
    Parameters:
    
    reference - reference instant
    
    apparentOffset - apparent clock offset from the reference instant (difference between two readings in the specified time scale)
    
    timeScale - time scale with respect to which the offset is defined
    
    See Also:
    
    offsetFrom(FieldAbsoluteDate, TimeScale)
- Method Detail
  - parseCCSDSUnsegmentedTimeCode
```
public static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T> parseCCSDSUnsegmentedTimeCode(org.hipparchus.Field<T> field,
                                                                                                                byte preambleField1,
                                                                                                                byte preambleField2,
                                                                                                                byte[] timeField,
                                                                                                                FieldAbsoluteDate<T> agencyDefinedEpoch)
```
    Build an instance from a CCSDS Unsegmented Time Code (CUC).
    CCSDS Unsegmented Time Code is defined in the blue book: CCSDS Time Code Format (CCSDS 301.0-B-4) published in November 2010
    
    If the date to be parsed is formatted using version 3 of the standard (CCSDS 301.0-B-3 published in 2002) or if the extension of the preamble field introduced in version 4 of the standard is not used, then the preambleField2 parameter can be set to 0.
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    field - field for the components
    
    preambleField1 - first byte of the field specifying the format, often not transmitted in data interfaces, as it is constant for a given data interface
    
    preambleField2 - second byte of the field specifying the format (added in revision 4 of the CCSDS standard in 2010), often not transmitted in data interfaces, as it is constant for a given data interface (value ignored if presence not signaled in preambleField1)
    
    timeField - byte array containing the time code
    
    agencyDefinedEpoch - reference epoch, ignored if the preamble field specifies the CCSDS reference epoch is used (and hence may be null in this case)
    
    Returns:
    
    an instance corresponding to the specified date
  - parseCCSDSDaySegmentedTimeCode
```
public static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T> parseCCSDSDaySegmentedTimeCode(org.hipparchus.Field<T> field,
                                                                                                                 byte preambleField,
                                                                                                                 byte[] timeField,
                                                                                                                 DateComponents agencyDefinedEpoch)
```
    Build an instance from a CCSDS Day Segmented Time Code (CDS).
    CCSDS Day Segmented Time Code is defined in the blue book: CCSDS Time Code Format (CCSDS 301.0-B-4) published in November 2010
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    field - field for the components
    
    preambleField - field specifying the format, often not transmitted in data interfaces, as it is constant for a given data interface
    
    timeField - byte array containing the time code
    
    agencyDefinedEpoch - reference epoch, ignored if the preamble field specifies the CCSDS reference epoch is used (and hence may be null in this case)
    
    Returns:
    
    an instance corresponding to the specified date
  - parseCCSDSCalendarSegmentedTimeCode
```
public FieldAbsoluteDate<T> parseCCSDSCalendarSegmentedTimeCode(byte preambleField,
                                                                byte[] timeField)
```
    Build an instance from a CCSDS Calendar Segmented Time Code (CCS).
    CCSDS Calendar Segmented Time Code is defined in the blue book: CCSDS Time Code Format (CCSDS 301.0-B-4) published in November 2010
    
    Parameters:
    
    preambleField - field specifying the format, often not transmitted in data interfaces, as it is constant for a given data interface
    
    timeField - byte array containing the time code
    
    Returns:
    
    an instance corresponding to the specified date
  - createJDDate
```
public static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T> createJDDate(int jd,
                                                                                               T secondsSinceNoon,
                                                                                               TimeScale timeScale)
```
    Build an instance corresponding to a Julian Day date.
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    jd - Julian day
    
    secondsSinceNoon - seconds in the Julian day (BEWARE, Julian days start at noon, so 0.0 is noon)
    
    timeScale - time scale in which the seconds in day are defined
    
    Returns:
    
    a new instant
  - createMJDDate
```
public static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T> createMJDDate(int mjd,
                                                                                                T secondsInDay,
                                                                                                TimeScale timeScale)
```
    Build an instance corresponding to a Modified Julian Day date.
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    mjd - modified Julian day
    
    secondsInDay - seconds in the day
    
    timeScale - time scale in which the seconds in day are defined
    
    Returns:
    
    a new instant
  - createGPSDate
```
public static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T> createGPSDate(int weekNumber,
                                                                                                T milliInWeek)
```
    Build an instance corresponding to a GPS date.
    GPS dates are provided as a week number starting at GPS epoch and as a number of milliseconds since week start.
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    weekNumber - week number since GPS epoch
    
    milliInWeek - number of milliseconds since week start
    
    Returns:
    
    a new instant
  - createJulianEpoch
```
public static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T> createJulianEpoch(T julianEpoch)
```
    Build an instance corresponding to a Julian Epoch (JE).
    According to Lieske paper: Precession Matrix Based on IAU (1976) System of Astronomical Constants, Astronomy and Astrophysics, vol. 73, no. 3, Mar. 1979, p. 282-284, Julian Epoch is related to Julian Ephemeris Date as:
    
    JE = 2000.0 + (JED - 2451545.0) / 365.25
    
    This method reverts the formula above and computes an FieldAbsoluteDate<T> from the Julian Epoch.
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    julianEpoch - Julian epoch, like 2000.0 for defining the classical reference J2000.0
    
    Returns:
    
    a new instant
    
    See Also:
    
    getJ2000Epoch(Field), createBesselianEpoch(RealFieldElement)
  - createBesselianEpoch
```
public static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T> createBesselianEpoch(T besselianEpoch)
```
    Build an instance corresponding to a Besselian Epoch (BE).
    According to Lieske paper: Precession Matrix Based on IAU (1976) System of Astronomical Constants, Astronomy and Astrophysics, vol. 73, no. 3, Mar. 1979, p. 282-284, Besselian Epoch is related to Julian Ephemeris Date as:
    
    BE = 1900.0 + (JED - 2415020.31352) / 365.242198781
    
    This method reverts the formula above and computes an FieldAbsoluteDate<T> from the Besselian Epoch.
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    besselianEpoch - Besselian epoch, like 1950 for defining the classical reference B1950.0
    
    Returns:
    
    a new instant
    
    See Also:
    
    createJulianEpoch(RealFieldElement)
  - getJulianEpoch
```
public static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T> getJulianEpoch(org.hipparchus.Field<T> field)
```
    Reference epoch for julian dates: -4712-01-01T12:00:00 Terrestrial Time.
    Both java.util.Date and DateComponents classes follow the astronomical conventions and consider a year 0 between years -1 and +1, hence this reference date lies in year -4712 and not in year -4713 as can be seen in other documents or programs that obey a different convention (for example the convcal utility).
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    field - field for the components
    
    Returns:
    
    FieldAbsoluteDate FieldAbsoluteDate representing AbsoluteDate.JULIAN_EPOCH
  - getModifiedJulianEpoch
```
public static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T> getModifiedJulianEpoch(org.hipparchus.Field<T> field)
```
    Reference epoch for modified julian dates: 1858-11-17T00:00:00 Terrestrial Time.
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    field - field for the components
    
    Returns:
    
    FieldAbsoluteDate FieldAbsoluteDate representing AbsoluteDate.MODIFIED_JULIAN_EPOCH
  - getFiftiesEpoch
```
public static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T> getFiftiesEpoch(org.hipparchus.Field<T> field)
```
    Reference epoch for 1950 dates: 1950-01-01T00:00:00 Terrestrial Time.
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    field - field for the components
    
    Returns:
    
    FieldAbsoluteDate FieldAbsoluteDate representing AbsoluteDate.FIFTIES_EPOCH
  - getCCSDSEpoch
```
public static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T> getCCSDSEpoch(org.hipparchus.Field<T> field)
```
    Reference epoch for CCSDS Time Code Format (CCSDS 301.0-B-4): 1958-01-01T00:00:00 International Atomic Time (not UTC).
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    field - field for the components
    
    Returns:
    
    FieldAbsoluteDate FieldAbsoluteDate representing AbsoluteDate.CCSDS_EPOCH
  - getGalileoEpoch
```
public static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T> getGalileoEpoch(org.hipparchus.Field<T> field)
```
    Reference epoch for Galileo System Time: 1999-08-22T00:00:00 UTC.
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    field - field for the components
    
    Returns:
    
    FieldAbsoluteDate FieldAbsoluteDate representing AbsoluteDate.GALILEO_EPOCH
  - getGPSEpoch
```
public static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T> getGPSEpoch(org.hipparchus.Field<T> field)
```
    Reference epoch for GPS weeks: 1980-01-06T00:00:00 GPS time.
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    field - field for the components
    
    Returns:
    
    FieldAbsoluteDate FieldAbsoluteDate representing AbsoluteDate.GPS_EPOCH
  - getJ2000Epoch
```
public static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T> getJ2000Epoch(org.hipparchus.Field<T> field)
```
    J2000.0 Reference epoch: 2000-01-01T12:00:00 Terrestrial Time (not UTC).
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    field - field for the components
    
    Returns:
    
    FieldAbsoluteDate FieldAbsoluteDate representing AbsoluteDate.J2000_EPOCH
    
    See Also:
    
    createJulianEpoch(RealFieldElement), createBesselianEpoch(RealFieldElement)
  - getJavaEpoch
```
public static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T> getJavaEpoch(org.hipparchus.Field<T> field)
```
    Java Reference epoch: 1970-01-01T00:00:00 Universal Time Coordinate.
    Between 1968-02-01 and 1972-01-01, UTC-TAI = 4.213 170 0s + (MJD - 39 126) x 0.002 592s. As on 1970-01-01 MJD = 40587, UTC-TAI = 8.000082s
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    field - field for the components
    
    Returns:
    
    FieldAbsoluteDate FieldAbsoluteDate representing AbsoluteDate.JAVA_EPOCH
  - getPastInfinity
```
public static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T> getPastInfinity(org.hipparchus.Field<T> field)
```
    Dummy date at infinity in the past direction.
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    field - field for the components
    
    Returns:
    
    FieldAbsoluteDate FieldAbsoluteDate representing AbsoluteDate.PAST_INFINITY
  - getFutureInfinity
```
public static <T extends org.hipparchus.RealFieldElement<T>> FieldAbsoluteDate<T> getFutureInfinity(org.hipparchus.Field<T> field)
```
    Dummy date at infinity in the future direction.
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    field - field for the components
    
    Returns:
    
    FieldAbsoluteDate FieldAbsoluteDate representing AbsoluteDate.FUTURE_INFINITY
  - shiftedBy
```
public FieldAbsoluteDate<T> shiftedBy(T dt)
```
    Get a time-shifted date.
    Calling this method is equivalent to call new FieldAbsoluteDate<>(this, dt).
    
    Parameters:
    
    dt - time shift in seconds
    
    Returns:
    
    a new date, shifted with respect to instance (which is immutable)
    
    See Also:
    
    PVCoordinates.shiftedBy(double), Attitude.shiftedBy(double), Orbit.shiftedBy(double), SpacecraftState.shiftedBy(double)
  - durationFrom
```
public T durationFrom(FieldAbsoluteDate<T> instant)
```
    Compute the physically elapsed duration between two instants.
    The returned duration is the number of seconds physically elapsed between the two instants, measured in a regular time scale with respect to surface of the Earth (i.e either the TAI scale, the TT scale or the GPS scale). It is the only method that gives a duration with a physical meaning.
    
    This method gives the same result (with less computation) as calling offsetFrom(FieldAbsoluteDate, TimeScale) with a second argument set to one of the regular scales cited above.
    
    This method is the reverse of the FieldAbsoluteDate(FieldAbsoluteDate, double) constructor.
    
    Parameters:
    
    instant - instant to subtract from the instance
    
    Returns:
    
    offset in seconds between the two instants (positive if the instance is posterior to the argument)
    
    See Also:
    
    offsetFrom(FieldAbsoluteDate, TimeScale), FieldAbsoluteDate(FieldAbsoluteDate, double)
  - durationFrom
```
public T durationFrom(AbsoluteDate instant)
```
    Compute the physically elapsed duration between two instants.
    The returned duration is the number of seconds physically elapsed between the two instants, measured in a regular time scale with respect to surface of the Earth (i.e either the TAI scale, the TT scale or the GPS scale). It is the only method that gives a duration with a physical meaning.
    
    This method gives the same result (with less computation) as calling offsetFrom(FieldAbsoluteDate, TimeScale) with a second argument set to one of the regular scales cited above.
    
    This method is the reverse of the FieldAbsoluteDate(FieldAbsoluteDate, double) constructor.
    
    Parameters:
    
    instant - instant to subtract from the instance
    
    Returns:
    
    offset in seconds between the two instants (positive if the instance is posterior to the argument)
    
    See Also:
    
    offsetFrom(FieldAbsoluteDate, TimeScale), FieldAbsoluteDate(FieldAbsoluteDate, double)
  - offsetFrom
```
public T offsetFrom(FieldAbsoluteDate<T> instant,
                    TimeScale timeScale)
```
    Compute the apparent clock offset between two instant in the perspective of a specific time scale.
    The offset is the number of seconds counted in the given time scale between the locations of the two instants, with all time scale irregularities removed (i.e. considering all days are exactly 86400 seconds long). This method will give a result that may not have a physical meaning if the time scale is irregular. For example since a leap second was introduced at the end of 2005, the apparent offset between 2005-12-31T23:59:59 and 2006-01-01T00:00:00 is 1 second, but the physical duration of the corresponding time interval as returned by the durationFrom(FieldAbsoluteDate) method is 2 seconds.
    
    This method is the reverse of the FieldAbsoluteDate(FieldAbsoluteDate, double, TimeScale) constructor.
    
    Parameters:
    
    instant - instant to subtract from the instance
    
    timeScale - time scale with respect to which the offset should be computed
    
    Returns:
    
    apparent clock offset in seconds between the two instants (positive if the instance is posterior to the argument)
    
    See Also:
    
    durationFrom(FieldAbsoluteDate), FieldAbsoluteDate(FieldAbsoluteDate, double, TimeScale)
  - timeScalesOffset
```
public T timeScalesOffset(TimeScale scale1,
                          TimeScale scale2)
```
    Compute the offset between two time scales at the current instant.
    The offset is defined as l₁-l₂ where l₁ is the location of the instant in the scale1 time scale and l₂ is the location of the instant in the scale2 time scale.
    
    Parameters:
    
    scale1 - first time scale
    
    scale2 - second time scale
    
    Returns:
    
    offset in seconds between the two time scales at the current instant
  - toDate
```
public Date toDate(TimeScale timeScale)
```
    Convert the instance to a Java Date.
    Conversion to the Date class induces a loss of precision because the Date class does not provide sub-millisecond information. Java Dates are considered to be locations in some times scales.
    
    Parameters:
    
    timeScale - time scale to use
    
    Returns:
    
    a Date instance representing the location of the instant in the time scale
  - getComponents
```
public DateTimeComponents getComponents(TimeScale timeScale)
```
    Split the instance into date/time components.
    
    Parameters:
    
    timeScale - time scale to use
    
    Returns:
    
    date/time components
  - getComponents
```
public DateTimeComponents getComponents(int minutesFromUTC)
```
    Split the instance into date/time components for a local time.
    
    Parameters:
    
    minutesFromUTC - offset in minutes from UTC (positive Eastwards UTC, negative Westward UTC)
    
    Returns:
    
    date/time components
  - getDate
```
public FieldAbsoluteDate<T> getDate()
```
    Get the date.
    
    Specified by:
    
    getDate in interface FieldTimeStamped<T extends org.hipparchus.RealFieldElement<T>>
    
    Returns:
    
    date attached to the object
  - getField
```
public org.hipparchus.Field<T> getField()
```
    Get the field.
    
    Returns:
    
    field instance.
  - getComponents
```
public DateTimeComponents getComponents(TimeZone timeZone)
```
    Split the instance into date/time components for a time zone.
    
    Parameters:
    
    timeZone - time zone
    
    Returns:
    
    date/time components
  - compareTo
```
public int compareTo(FieldAbsoluteDate<T> date)
```
    Compare the instance with another date.
    
    Specified by:
    
    compareTo in interface Comparable<T extends org.hipparchus.RealFieldElement<T>>
    
    Parameters:
    
    date - other date to compare the instance to
    
    Returns:
    
    a negative integer, zero, or a positive integer as this date is before, simultaneous, or after the specified date.
  - equals
```
public boolean equals(Object date)
```
    Check if the instance represent the same time as another instance.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    date - other date
    
    Returns:
    
    true if the instance and the other date refer to the same instant
  - hashCode
```
public int hashCode()
```
    Get a hashcode for this date.
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    hashcode
  - toString
```
public String toString()
```
    Get a String representation of the instant location in UTC time scale.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    a string representation of the instance, in ISO-8601 format with milliseconds accuracy
  - toString
```
public String toString(TimeScale timeScale)
```
    Get a String representation of the instant location.
    
    Parameters:
    
    timeScale - time scale to use
    
    Returns:
    
    a string representation of the instance, in ISO-8601 format with milliseconds accuracy
  - toString
```
public String toString(int minutesFromUTC)
```
    Get a String representation of the instant location for a local time.
    
    Parameters:
    
    minutesFromUTC - offset in minutes from UTC (positive Eastwards UTC, negative Westward UTC).
    
    Returns:
    
    string representation of the instance, in ISO-8601 format with milliseconds accuracy
  - toString
```
public String toString(TimeZone timeZone)
```
    Get a String representation of the instant location for a time zone.
    
    Parameters:
    
    timeZone - time zone
    
    Returns:
    
    string representation of the instance, in ISO-8601 format with milliseconds accuracy
  - shiftedBy
```
public FieldAbsoluteDate<T> shiftedBy(double dt)
```
    Get a time-shifted date.
    Calling this method is equivalent to call new AbsoluteDate(this, dt).
    
    Specified by:
    
    shiftedBy in interface TimeShiftable<T extends org.hipparchus.RealFieldElement<T>>
    
    Parameters:
    
    dt - time shift in seconds
    
    Returns:
    
    a new date, shifted with respect to instance (which is immutable)
    
    See Also:
    
    PVCoordinates.shiftedBy(double), Attitude.shiftedBy(double), Orbit.shiftedBy(double), SpacecraftState.shiftedBy(double)
  - toAbsoluteDate
```
public AbsoluteDate toAbsoluteDate()
```
    Transform the FieldAbsoluteDate in an AbsoluteDate.
    
    Returns:
    
    AbsoluteDate of the FieldObject

Class FieldAbsoluteDate<T extends org.hipparchus.RealFieldElement<T>>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

FieldAbsoluteDate

Method Detail

parseCCSDSUnsegmentedTimeCode

parseCCSDSDaySegmentedTimeCode

parseCCSDSCalendarSegmentedTimeCode

createJDDate

createMJDDate

createGPSDate

createJulianEpoch

createBesselianEpoch

getJulianEpoch

getModifiedJulianEpoch

getFiftiesEpoch

getCCSDSEpoch

getGalileoEpoch

getGPSEpoch

getJ2000Epoch

getJavaEpoch

getPastInfinity

getFutureInfinity

shiftedBy

durationFrom

durationFrom

offsetFrom

timeScalesOffset

toDate

getComponents

getComponents

getDate

getField

getComponents

compareTo

equals

hashCode

toString

toString

toString

toString

shiftedBy

toAbsoluteDate