JulianDate

java.lang.Object
- agi.foundation.time.JulianDate

All Implemented Interfaces:

IEquatable<JulianDate>, ImmutableValueType, ValueType, IEquatableEpsilon<JulianDate>, Comparable<JulianDate>
```
public final class JulianDate
extends Object
implements Comparable<JulianDate>, IEquatable<JulianDate>, IEquatableEpsilon<JulianDate>, ImmutableValueType
```
An astronomical Julian Date, which is the number of days since noon on January 1, -4712 (4713 BC). For increased precision, this class stores the whole number part of the date as an int and the seconds into the day as a double.

This type assumes that days always have TimeConstants.SecondsPerDay (86400.0) seconds. When using a JulianDate with the CoordinatedUniversalTime (get) (UTC) time standard, a day with a leap second actually has 86401.0 seconds. The end result is that JulianDate cannot represent the moment of a leap second in the UTC time standard. However, it CAN represent the moment of a leap second in InternationalAtomicTime (get) (TAI). Also, subtracting two UTC dates that are on opposite sides of a leap second will correctly take the leap second into account.

Constructor Summary

Constructors
Constructor and Description
`JulianDate()` Initializes a new instance.
`JulianDate(double dayCount)` Initializes a `JulianDate` from a double expressing the complete astronomical Julian Date.
`JulianDate(double dayCount, TimeStandard timeStandard)` Initializes a `JulianDate` from a double expressing the complete astronomical Julian Date.
`JulianDate(GregorianDate gregorianDate)` Initializes a `JulianDate` from a `GregorianDate`.
`JulianDate(GregorianDate gregorianDate, TimeStandard standard)` Initializes a `JulianDate` from a `GregorianDate` where the `GregorianDate` is expressed in the given `TimeStandard`.
`JulianDate(int day, double secondsOfDay)` Initializes a `JulianDate` from the provided values.
`JulianDate(int day, double secondsOfDay, TimeStandard timeStandard)` Initializes a `JulianDate` from the provided values.
`JulianDate(ZonedDateTime dateTime)` Initializes a `JulianDate` from a `ZonedDateTime`.
`JulianDate(ZonedDateTime dateTime, TimeStandard standard)` Initializes a `JulianDate` from a `ZonedDateTime` and specified time standard.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`JulianDate`	`add(Duration duration)` Adds a `Duration` to this Julian date, producing a new `JulianDate`.
`static JulianDate`	`add(JulianDate left, Duration right)` Adds a `Duration` to a `JulianDate`, producing a new `JulianDate`.
`JulianDate`	`addClamped(Duration duration)` Adds a `Duration` to this Julian date, producing a new `JulianDate`.
`JulianDate`	`addDays(double days)` Adds the specified number of days to this date and returns the new date.
`JulianDate`	`addHours(double hours)` Adds the specified number of hours to this date and returns the new date.
`JulianDate`	`addMinutes(double minutes)` Adds the specified number of minutes to this date and returns the new date.
`JulianDate`	`addSeconds(double seconds)` Adds the specified number of seconds to this date and returns the new date.
`int`	`compareTo(JulianDate other)` Compares this instance with another instance of the same type.
`double`	`daysDifference(JulianDate other)` Computes the number of days that have elapsed from this Julian date to the `other` Julian date.
`static boolean`	`equals(JulianDate left, JulianDate right)` Returns true if two dates are exactly equal.
`boolean`	`equals(Object obj)` Returns true if this date exactly equals another date.
`boolean`	`equalsEpsilon(JulianDate other, double epsilon)` Returns true if this date is within `epsilon` seconds of the specified date.
`boolean`	`equalsType(JulianDate other)` Returns true if this date exactly equals another date.
`static JulianDate`	`getCenterOfWindow(JulianDate referenceEpoch, double windowLength, JulianDate date)` Divides time into windows, each of length `windowLength` seconds, with the first window centered on `referenceEpoch`.
`int`	`getDay()` Gets the integer portion of the Julian Date (or astronomical Julian day number).
`static JulianDate`	`getMaxValue()` Gets the largest possible value of `JulianDate`.
`static JulianDate`	`getMinValue()` Gets the smallest value possible of `JulianDate`.
`static JulianDate`	`getNow()` Gets the `JulianDate` that represents the current system date and time.
`double`	`getSecondsOfDay()` Gets the number of seconds past noon on the whole-number Julian Day.
`TimeStandard`	`getStandard()` Gets the `TimeStandard` that this astronomical Julian date is based upon.
`double`	`getTotalDays()` Gets the total number of whole and fractional days represented by this astronomical Julian date.
`static boolean`	`greaterThan(JulianDate left, JulianDate right)` Returns true if `left` occurs after `right`.
`static boolean`	`greaterThanOrEqual(JulianDate left, JulianDate right)` Returns true if `left` occurs after or at the same time as `right`.
`int`	`hashCode()` Returns a hash code for this instance, which is suitable for use in hashing algorithms and data structures like a hash table.
`boolean`	`isIdentical(JulianDate other)` Returns true if this date is identical to another date.
`static double`	`julianDateToYearFraction(JulianDate julianDate)` Computes the fraction of the year corresponding to the given Julian date.
`static boolean`	`lessThan(JulianDate left, JulianDate right)` Returns true if `left` occurs before `right`.
`static boolean`	`lessThanOrEqual(JulianDate left, JulianDate right)` Returns true if `left` occurs before or at the same time as `right`.
`double`	`minutesDifference(JulianDate other)` Computes the number of minutes that have elapsed from this Julian date to the `other` Julian date.
`static boolean`	`notEquals(JulianDate left, JulianDate right)` Returns true if two dates are NOT exactly equal.
`double`	`secondsDifference(JulianDate other)` Computes the number of seconds that have elapsed from this Julian date to the `other` Julian date.
`JulianDate`	`subtract(Duration duration)` Subtracts a `Duration` from this Julian date, producing a new `JulianDate`.
`Duration`	`subtract(JulianDate subtrahend)` Subtracts another Julian date from this Julian date.
`static JulianDate`	`subtract(JulianDate left, Duration right)` Subtracts a `Duration` from a Julian date, producing a new `JulianDate`.
`static Duration`	`subtract(JulianDate left, JulianDate right)` Subtracts a Julian date from another Julian date, producing a `Duration`.
`JulianDate`	`subtractDays(double days)` Subtracts the specified number of days from this date and returns the new date.
`JulianDate`	`subtractHours(double hours)` Subtracts the specified number of hours from this date and returns the new date.
`JulianDate`	`subtractMinutes(double minutes)` Subtracts the specified number of minutes from this date and returns the new date.
`JulianDate`	`subtractSeconds(double seconds)` Subtracts the specified number of seconds to this date and returns the new date.
`ZonedDateTime`	`toDateTime()` Converts this `JulianDate` to a `ZonedDateTime` with a default time standard of `CoordinatedUniversalTime` (`get`) (UTC).
`ZonedDateTime`	`toDateTime(TimeStandard standard)` Converts this `JulianDate` to a `ZonedDateTime` expressed in the specified time standard.
`GregorianDate`	`toGregorianDate()` Converts this `JulianDate` to a `GregorianDate` with a default time standard of `CoordinatedUniversalTime` (`get`) (UTC).
`GregorianDate`	`toGregorianDate(TimeStandard standard)` Converts this `JulianDate` to a `GregorianDate` expressed in the specified time standard.
`String`	`toString()` Returns the value of this `JulianDate` in the standard format.
`JulianDate`	`toTimeStandard(TimeStandard timeStandard)` Converts this `JulianDate` to the specified time standard.
`boolean`	`tryConvertTimeStandard(TimeStandard timeStandard, JulianDate[] result)` Try to convert this `JulianDate` to the specified `TimeStandard`, if the specified `TimeStandard` is capable of representing this time.

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

Constructor Detail
- JulianDate
```
public JulianDate()
```
  Initializes a new instance.
- JulianDate
```
public JulianDate(@Nonnull
                  ZonedDateTime dateTime)
```
  Initializes a JulianDate from a ZonedDateTime. The time standard will be CoordinatedUniversalTime (get) (UTC).
  
  Parameters:
  
  dateTime - The ZonedDateTime.
- JulianDate
```
public JulianDate(@Nonnull
                  GregorianDate gregorianDate)
```
  Initializes a JulianDate from a GregorianDate. The time standard will be CoordinatedUniversalTime (get) (UTC), except when the gregorianDate represents time during a leap second. During a leap second, the JulianDate will be in the InternationalAtomicTime (get) (TAI) standard.
  
  Parameters:
  
  gregorianDate - The GregorianDate to use to specify the JulianDate.
- JulianDate
```
public JulianDate(@Nonnull
                  ZonedDateTime dateTime,
                  TimeStandard standard)
```
  Initializes a JulianDate from a ZonedDateTime and specified time standard.
  
  Parameters:
  
  dateTime - The ZonedDateTime.
  
  standard - The time standard to use for this Julian Date. The dateTime is assumed to be expressed in this time standard.
- JulianDate
```
public JulianDate(@Nonnull
                  GregorianDate gregorianDate,
                  TimeStandard standard)
```
  Initializes a JulianDate from a GregorianDate where the GregorianDate is expressed in the given TimeStandard. If the date is during a leap second, the JulianDate will be expressed in InternationalAtomicTime (get) (TAI).
  
  Parameters:
  
  gregorianDate - The GregorianDate.
  
  standard - The time standard in which the gregorianDate is expressed.
- JulianDate
```
public JulianDate(int day,
                  double secondsOfDay)
```
  Initializes a JulianDate from the provided values. The values will be normalized so that the SecondsOfDay (get) property is less than the length of a day. The time standard will be International Atomic Time (TAI).
  
  Parameters:
  
  day - The whole number part of the date.
  
  secondsOfDay - The time of day, expressed as seconds past noon on the given whole-number day.
  
  Throws:
  
  ArgumentOutOfRangeException - Thrown when the result represents a value too large to be stored in a JulianDate.
- JulianDate
```
public JulianDate(int day,
                  double secondsOfDay,
                  TimeStandard timeStandard)
```
  Initializes a JulianDate from the provided values. The values will be normalized so that the SecondsOfDay (get) property is less than the length of the day.
  
  Parameters:
  
  day - The whole number part of the date.
  
  secondsOfDay - The time of day, expressed as seconds past noon on the given whole-number day.
  
  timeStandard - The time standard to use for this Julian Date.
  
  Throws:
  
  ArgumentOutOfRangeException - Thrown when the result represents a value too large to be stored in a JulianDate.
- JulianDate
```
public JulianDate(double dayCount)
```
  Initializes a JulianDate from a double expressing the complete astronomical Julian Date. The time standard will be InternationalAtomicTime (get).
  
  Parameters:
  
  dayCount - The complete astronomical Julian date.
  
  Throws:
  
  ArgumentOutOfRangeException - Thrown when the result represents a value too large to be stored in a JulianDate.
- JulianDate
```
public JulianDate(double dayCount,
                  TimeStandard timeStandard)
```
  Initializes a JulianDate from a double expressing the complete astronomical Julian Date.
  
  Parameters:
  
  dayCount - The complete Julian date.
  
  timeStandard - The time standard to use for this Julian Date.
  
  Throws:
  
  ArgumentOutOfRangeException - Thrown when the result represents a value too large to be stored in a JulianDate.

Method Detail

getMinValue
```
@Nonnull
public static JulianDate getMinValue()
```
Gets the smallest value possible of JulianDate. This date is in InternationalAtomicTime (get) and may not be representable in other time standards.

getMaxValue
```
@Nonnull
public static JulianDate getMaxValue()
```
Gets the largest possible value of JulianDate. This date is in InternationalAtomicTime (get) and may not be representable in other time standards.

getTotalDays
```
public final double getTotalDays()
```
Gets the total number of whole and fractional days represented by this astronomical Julian date.

getDay
```
public final int getDay()
```
Gets the integer portion of the Julian Date (or astronomical Julian day number).

getSecondsOfDay
```
public final double getSecondsOfDay()
```
Gets the number of seconds past noon on the whole-number Julian Day.

getStandard
```
@Nonnull
public final TimeStandard getStandard()
```
Gets the TimeStandard that this astronomical Julian date is based upon.

getNow
```
@Nonnull
public static JulianDate getNow()
```
Gets the JulianDate that represents the current system date and time. The time standard will be CoordinatedUniversalTime (get) (UTC).

toTimeStandard
```
@Nonnull
public final JulianDate toTimeStandard(@Nullable
                                                 TimeStandard timeStandard)
```
Converts this JulianDate to the specified time standard.
If timeStandard is null, no conversion will be performed.

Parameters:

timeStandard - The requested time standard.

Returns:

An equivalent JulianDate using the requested time standard.

Throws:

ArgumentOutOfRangeException - Thrown when the specified TimeStandard is not capable of representing this JulianDate.

tryConvertTimeStandard
```
public final boolean tryConvertTimeStandard(@Nullable
                                            TimeStandard timeStandard,
                                            @Nonnull
                                            JulianDate[] result)
```
Try to convert this JulianDate to the specified TimeStandard, if the specified TimeStandard is capable of representing this time.
If timeStandard is null, no conversion will be performed.

Parameters:

timeStandard - The requested time standard.

result - On input, an array with one element. On return, the array is populated with an equivalent JulianDate using the requested TimeStandard, if it is capable of representing this time; otherwise MinValue (get).

Returns:

true if this date could be converted to the requested TimeStandard; otherwise false.

secondsDifference
```
public final double secondsDifference(@Nonnull
                                      JulianDate other)
```
Computes the number of seconds that have elapsed from this Julian date to the other Julian date.
This method subtracts the Julian date on which it is called from the other Julian date and returns the number of seconds between them. The computation is done in the time standard of this Julian date, or the closest standard that is safe for arithmetic if this Julian date's time standard is not safe. For best performance, this Julian date and the other Julian date should have the same time standard, and it should be safe for arithmetic.

Parameters:

other - The other Julian date, which is the end of the interval.

Returns:

The number of seconds that have elapsed from this Julian date to the other Julian date.

minutesDifference
```
public final double minutesDifference(@Nonnull
                                      JulianDate other)
```
Computes the number of minutes that have elapsed from this Julian date to the other Julian date.
This method subtracts the Julian date on which it is called from the other Julian date and returns the number of minutes between them. The computation is done in the time standard of this Julian date, or the closest standard that is safe for arithmetic if this Julian date's time standard is not safe. For best performance, this Julian date and the other Julian date should have the same time standard, and it should be safe for arithmetic.

Parameters:

other - The other Julian date, which is the end of the interval.

Returns:

The number of minutes that have elapsed from this Julian date to the other Julian date.

daysDifference
```
public final double daysDifference(@Nonnull
                                   JulianDate other)
```
Computes the number of days that have elapsed from this Julian date to the other Julian date.
This method subtracts the Julian date on which it is called from the other Julian date and returns the number of days between them. The computation is done in the time standard of this Julian date, or the closest standard that is safe for arithmetic if this Julian date's time standard is not safe. For best performance, this Julian date and the other Julian date should have the same time standard, and it should be safe for arithmetic.

Parameters:

other - The other Julian date, which is the end of the interval.

Returns:

The number of days that have elapsed from this Julian date to the other Julian date.

add
```
@Nonnull
public final JulianDate add(@Nonnull
                                      Duration duration)
```
Adds a Duration to this Julian date, producing a new JulianDate.
If the Standard (get) of duration is different from the Standard (get) of this JulianDate, this JulianDate will be converted to duration's time standard before performing the addition. Then, the result will be converted to this JulianDate's time standard before it is returned, unless the result cannot be represented in this JulianDate's time standard, in which case it will remain in a TimeStandard that can represent the result.

Parameters:

duration - The duration to add.

Returns:

A new JulianDate that is the result of the addition.

Throws:

ArgumentOutOfRangeException - Thrown when the result represents a value too large to be stored in a JulianDate.

addClamped
```
@Nonnull
public final JulianDate addClamped(@Nonnull
                                             Duration duration)
```
Adds a Duration to this Julian date, producing a new JulianDate. Unlike JulianDate.add(Duration), this method will clamp the result to the valid range of values for JulianDate rather than throwing an exception. In most cases, JulianDate.add(Duration) should be used instead.
If the Standard (get) of duration is different from the Standard (get) of this JulianDate, the JulianDate will be converted to duration's time standard before performing the addition. Then, the result will be converted to this JulianDate's time standard before it is returned, unless the result cannot be represented in this JulianDate's time standard, in which case it will remain in a TimeStandard that can represent the result.

Parameters:

duration - The duration to add.

Returns:

A new JulianDate that is the result of the addition. If the result would exceed the valid range of values for a JulianDate, the value is clamped to MaxValue (get) or MinValue (get).

subtract
```
@Nonnull
public final Duration subtract(@Nonnull
                                         JulianDate subtrahend)
```
Subtracts another Julian date from this Julian date.
This method subtracts the subtrahend Julian date from this Julian date and returns the Duration between them. The computation is done in the time standard of the subtrahend, or the closest standard that is safe for arithmetic if the subtrahend's time standard is not safe. For best performance, this Julian date and the subtrahend Julian date should have the same time standard, and it should be safe for arithmetic.

Parameters:

subtrahend - The Julian Date to subtract from this Julian Date.

Returns:

The Duration that is the result of the subtraction. The time standard will be the same as the time standard of the subtrahend.

Throws:

ArgumentOutOfRangeException - Thrown when the result represents a value too large to be stored in a Duration.

subtract
```
@Nonnull
public final JulianDate subtract(@Nonnull
                                           Duration duration)
```
Subtracts a Duration from this Julian date, producing a new JulianDate.
If the Standard (get) of duration is different from the Standard (get) of this JulianDate, this JulianDate will be converted to duration's time standard before performing the subtraction. Then, the result will be converted to this JulianDate's time standard before it is returned, unless the result cannot be represented in this JulianDate's time standard, in which case it will remain in a TimeStandard that can represent the result.

Parameters:

duration - The duration to subtract.

Returns:

A new JulianDate that is the result of the subtraction.

Throws:

ArgumentOutOfRangeException - Thrown when the result represents a value too large to be stored in a JulianDate.

addSeconds
```
@Nonnull
public final JulianDate addSeconds(double seconds)
```
Adds the specified number of seconds to this date and returns the new date.

Parameters:

seconds - The number of seconds.

Returns:

The new date.

Throws:

ArgumentOutOfRangeException - Thrown when the result represents a value too large to be stored in a JulianDate.

subtractSeconds
```
@Nonnull
public final JulianDate subtractSeconds(double seconds)
```
Subtracts the specified number of seconds to this date and returns the new date.

Parameters:

seconds - The number of seconds.

Returns:

The new date.

Throws:

ArgumentOutOfRangeException - Thrown when the result represents a value too large to be stored in a JulianDate.

addDays
```
@Nonnull
public final JulianDate addDays(double days)
```
Adds the specified number of days to this date and returns the new date.

Parameters:

days - The number of days.

Returns:

The new date.

Throws:

ArgumentOutOfRangeException - Thrown when the result represents a value too large to be stored in a JulianDate.

subtractDays
```
@Nonnull
public final JulianDate subtractDays(double days)
```
Subtracts the specified number of days from this date and returns the new date.

Parameters:

days - The number of days.

Returns:

The new date.

Throws:

ArgumentOutOfRangeException - Thrown when the result represents a value too large to be stored in a JulianDate.

addMinutes
```
@Nonnull
public final JulianDate addMinutes(double minutes)
```
Adds the specified number of minutes to this date and returns the new date.

Parameters:

minutes - The number of minutes.

Returns:

The new date.

Throws:

ArgumentOutOfRangeException - Thrown when the result represents a value too large to be stored in a JulianDate.

subtractMinutes
```
@Nonnull
public final JulianDate subtractMinutes(double minutes)
```
Subtracts the specified number of minutes from this date and returns the new date.

Parameters:

minutes - The number of minutes.

Returns:

The new date.

Throws:

ArgumentOutOfRangeException - Thrown when the result represents a value too large to be stored in a JulianDate.

addHours
```
@Nonnull
public final JulianDate addHours(double hours)
```
Adds the specified number of hours to this date and returns the new date.

Parameters:

hours - The number of hours.

Returns:

The new date.

Throws:

ArgumentOutOfRangeException - Thrown when the result represents a value too large to be stored in a JulianDate.

subtractHours
```
@Nonnull
public final JulianDate subtractHours(double hours)
```
Subtracts the specified number of hours from this date and returns the new date.

Parameters:

hours - The number of hours.

Returns:

The new date.

Throws:

ArgumentOutOfRangeException - Thrown when the result represents a value too large to be stored in a JulianDate.

subtract
```
@Nonnull
public static Duration subtract(@Nonnull
                                          JulianDate left,
                                          @Nonnull
                                          JulianDate right)
```
Subtracts a Julian date from another Julian date, producing a Duration.
This method subtracts right from left and returns the Duration between them. The computation is done in the time standard of right, or the closest standard that is safe for arithmetic if right's time standard is not safe. For best performance, the left and right Julian dates should have the same time standard, and it should be safe for arithmetic.

Parameters:

left - The minuend.

right - The subtrahend.

Returns:

The Duration that is the result of the subtraction; that is, left minus right. The time standard will be the same as the time standard of the subtrahend.

subtract
```
@Nonnull
public static JulianDate subtract(@Nonnull
                                            JulianDate left,
                                            @Nonnull
                                            Duration right)
```
Subtracts a Duration from a Julian date, producing a new JulianDate.
If the Standard (get) of right is different from the Standard (get) of left, left will be converted to right's time standard before performing the subtraction. Then, the result will be converted to left's time standard before it is returned, unless the result cannot be represented in left's time standard, in which case it will remain in a TimeStandard that can represent the result.

Parameters:

left - The minuend.

right - The subtrahend.

Returns:

A new JulianDate that is the result of the subtraction; that is, left minus right.

add
```
@Nonnull
public static JulianDate add(@Nonnull
                                       JulianDate left,
                                       @Nonnull
                                       Duration right)
```
Adds a Duration to a JulianDate, producing a new JulianDate.
If the Standard (get) of right is different from the Standard (get) of left, left will be converted to right's time standard before performing the addition. Then, the result will be converted to left's time standard before it is returned, unless the result cannot be represented in left's time standard, in which case it will remain in a TimeStandard that can represent the result.

Parameters:

left - The Julian date.

right - The duration.

Returns:

A new JulianDate that is the result of the addition.

equals
```
public static boolean equals(@Nonnull
                             JulianDate left,
                             @Nonnull
                             JulianDate right)
```
Returns true if two dates are exactly equal. To be considered equal, Day (get) and SecondsOfDay (get) must be identical when converted to a common time standard. It is highly recommended that you use JulianDate.equalsEpsilon(agi.foundation.time.JulianDate, double) or JulianDate.isIdentical(agi.foundation.time.JulianDate) instead of this method.

Parameters:

left - The date on the left side.

right - The date on the right side.

Returns:

true if the dates are equal; otherwise false.

notEquals
```
public static boolean notEquals(@Nonnull
                                JulianDate left,
                                @Nonnull
                                JulianDate right)
```
Returns true if two dates are NOT exactly equal. To be considered equal, Day (get) and SecondsOfDay (get) must be identical when converted to a common time standard. It is highly recommended that you use JulianDate.equalsEpsilon(agi.foundation.time.JulianDate, double) or JulianDate.isIdentical(agi.foundation.time.JulianDate) instead of this method.

Parameters:

left - The date on the left side.

right - The date on the right side.

Returns:

true if the dates are not equal; otherwise false.

lessThan

public static boolean lessThan(@Nonnull
                               JulianDate left,
                               @Nonnull
                               JulianDate right)

Returns true if left occurs before right.

Parameters:: left - The date on the left side.; right - The date on the right side.
Returns:: true if the left is less than right; otherwise false.

greaterThan

public static boolean greaterThan(@Nonnull
                                  JulianDate left,
                                  @Nonnull
                                  JulianDate right)

Returns true if left occurs after right.

Parameters:: left - The date on the left side.; right - The date on the right side.
Returns:: true if the left is greater than right; otherwise false.

lessThanOrEqual

public static boolean lessThanOrEqual(@Nonnull
                                      JulianDate left,
                                      @Nonnull
                                      JulianDate right)

Returns true if left occurs before or at the same time as right.

Parameters:: left - The date on the left side.; right - The date on the right side.
Returns:: true if the left is less than or equal to right; otherwise false.

greaterThanOrEqual

public static boolean greaterThanOrEqual(@Nonnull
                                         JulianDate left,
                                         @Nonnull
                                         JulianDate right)

Returns true if left occurs after or at the same time as right.

Parameters:: left - The date on the left side.; right - The date on the right side.
Returns:: true if the left is greater than or equal to right; otherwise false.

equals
```
public boolean equals(Object obj)
```
Returns true if this date exactly equals another date. To be considered equal, Day (get) and SecondsOfDay (get) must be identical when converted to a common time standard. It is highly recommended that you use JulianDate.equalsEpsilon(agi.foundation.time.JulianDate, double) or JulianDate.isIdentical(agi.foundation.time.JulianDate) instead of this method.

Overrides:

equals in class Object

Parameters:

obj - The object to compare to this instance.

Returns:

true if obj represents the same value as this instance; otherwise false.

See Also:

Object.hashCode(), HashMap

equalsType
```
public final boolean equalsType(@Nonnull
                                JulianDate other)
```
Returns true if this date exactly equals another date. To be considered equal, Day (get) and SecondsOfDay (get) must be identical when converted to a common time standard. It is highly recommended that you use JulianDate.equalsEpsilon(agi.foundation.time.JulianDate, double) or JulianDate.isIdentical(agi.foundation.time.JulianDate) instead of this method.

Specified by:

equalsType in interface IEquatable<JulianDate>

Parameters:

other - The date to compare to this instance.

Returns:

true if other represents the same value as this instance; otherwise false.

isIdentical
```
public final boolean isIdentical(@Nonnull
                                 JulianDate other)
```
Returns true if this date is identical to another date. Unlike JulianDate.equalsType(JulianDate), this method will consider two dates with different time standards to be different, even if the dates represent the same moment when expressed in the same time standard.

Parameters:

other - The date to compare to this instance.

Returns:

true if other is identical to this instance; otherwise false.

equalsEpsilon
```
public final boolean equalsEpsilon(@Nonnull
                                   JulianDate other,
                                   double epsilon)
```
Returns true if this date is within epsilon seconds of the specified date. That is, in order for the dates to be considered equal (and for this function to return true), the absolute value of the difference between them, in seconds, must be less than or equal to epsilon.

Specified by:

equalsEpsilon in interface IEquatableEpsilon<JulianDate>

Parameters:

other - The date to compare to this date.

epsilon - The largest difference between the dates, in seconds, such that they will be considered equal.

Returns:

true if the dates are equal as defined by the epsilon value.

hashCode
```
public int hashCode()
```
Returns a hash code for this instance, which is suitable for use in hashing algorithms and data structures like a hash table.

Overrides:

hashCode in class Object

Returns:

A hash code for the current object.

See Also:

Object.equals(java.lang.Object), System.identityHashCode(java.lang.Object)

toString
```
public String toString()
```
Returns the value of this JulianDate in the standard format.

Overrides:

toString in class Object

Returns:

The string.

compareTo

public final int compareTo(@Nonnull
                           JulianDate other)

Compares this instance with another instance of the same type.

Specified by:

compareTo in interface Comparable<JulianDate>

Parameters:

other - An object to compare with this instance.

Returns:

A value indicating the relative order of the objects being compared. The return value has these meanings:

Value	Meaning
Less than zero	This instance is less than `other`.
Zero	This instance is equal to `other`.
Greater than zero	This instance is greater than `other`.

toDateTime
```
@Nonnull
public final ZonedDateTime toDateTime()
```
Converts this JulianDate to a ZonedDateTime with a default time standard of CoordinatedUniversalTime (get) (UTC).

Returns:

The ZonedDateTime.

toDateTime
```
@Nonnull
public final ZonedDateTime toDateTime(TimeStandard standard)
```
Converts this JulianDate to a ZonedDateTime expressed in the specified time standard.

Parameters:

standard - The time standard in which to express the returned ZonedDateTime.

Returns:

The ZonedDateTime.

toGregorianDate
```
@Nonnull
public final GregorianDate toGregorianDate()
```
Converts this JulianDate to a GregorianDate with a default time standard of CoordinatedUniversalTime (get) (UTC).

Returns:

The GregorianDate.

Throws:

ArgumentOutOfRangeException - Thrown when this date is earlier than 1 AD or later than 9999 AD, which cannot be represented by GregorianDate.

toGregorianDate
```
@Nonnull
public final GregorianDate toGregorianDate(TimeStandard standard)
```
Converts this JulianDate to a GregorianDate expressed in the specified time standard.

Parameters:

standard - The time standard in which to express the returned GregorianDate.

Returns:

The GregorianDate.

Throws:

ArgumentOutOfRangeException - Thrown when this date is earlier than 1 AD or later than 9999 AD, which cannot be represented by GregorianDate.

getCenterOfWindow
```
@Nonnull
public static JulianDate getCenterOfWindow(@Nonnull
                                                     JulianDate referenceEpoch,
                                                     double windowLength,
                                                     @Nonnull
                                                     JulianDate date)
```
Divides time into windows, each of length windowLength seconds, with the first window centered on referenceEpoch. Then, identifies which window contains date and returns the date that is at the center of that window. This is helpful for computing a discrete value for a range of Julian dates.

Parameters:

referenceEpoch - The Julian date that defines the start of a window.

windowLength - The length of each window, in seconds.

date - The date to find.

Returns:

The date at the center of the window that contains the specified date.

julianDateToYearFraction

public static double julianDateToYearFraction(@Nonnull
                                              JulianDate julianDate)

Computes the fraction of the year corresponding to the given Julian date.

Parameters:: julianDate - The current Julian date.
Returns:: The year fraction.

Class JulianDate

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

JulianDate

JulianDate

JulianDate

JulianDate

JulianDate

JulianDate

JulianDate

JulianDate

Method Detail

getMinValue

getMaxValue

getTotalDays

getDay

getSecondsOfDay

getStandard

getNow

toTimeStandard

tryConvertTimeStandard

secondsDifference

minutesDifference

daysDifference

add

addClamped

subtract

subtract

addSeconds

subtractSeconds

addDays

subtractDays

addMinutes

subtractMinutes

addHours

subtractHours

subtract

subtract

add

equals

notEquals

lessThan

greaterThan

lessThanOrEqual

greaterThanOrEqual

equals

equalsType

isIdentical

equalsEpsilon

hashCode

toString

compareTo

toDateTime

toDateTime

toGregorianDate

toGregorianDate

getCenterOfWindow

julianDateToYearFraction