/** * Initializes a {@link JulianDate} from a {@link GregorianDate} where the {@link GregorianDate} is expressed in the given {@link TimeStandard}. If the date is during a leap second, the {@link JulianDate} will be expressed in {@link TimeStandard#INTERNATIONAL_ATOMIC_TIME} (TAI). * @param gregorianDate The {@link GregorianDate}. * @param standard The time standard in which the {@code gregorianDate} is expressed. */ public JulianDate(@Nonnull GregorianDate gregorianDate, @Nonnull TimeStandard standard) { JulianDate converted = gregorianDate.toJulianDate(standard); m_day = converted.m_day; m_secondsOfDay = converted.m_secondsOfDay; m_timeStandard = converted.getStandard(); }
/** * Returns a hash code for this instance, which is suitable for use in hashing algorithms and data structures like a hash table. * @return A hash code for the current object. */ @Override public int hashCode() { return HashCode.combine(Integer.hashCode(m_day), Double.hashCode(m_secondsOfDay), getStandard().hashCode()); }
/** * Initializes a new instance of a Leap Second. * @param date The date of the leap second. This date must be in Coordinated Universal Time (UTC). * @param totalTaiOffsetFromUtc The offset of TAI from UTC after this leap second. * @exception ArgumentException Thrown if the given date is not in UTC. */ public LeapSecond(@Nonnull JulianDate date, double totalTaiOffsetFromUtc) { if (date.getStandard() != TimeStandard.COORDINATED_UNIVERSAL_TIME) { throw new ArgumentException(CesiumLocalization.getDateMustBeUTC(), "date"); } m_date = date; m_totalTaiOffsetFromUtc = totalTaiOffsetFromUtc; }
/** * Returns a {@link TimeInterval} equivalent to this one where the time standard of the start and end dates has been converted to the specified standard. * @param timeStandard The time standard of the new interval. * @return An equivalent interval with the new time standard. */ @CS2JWarning("Unhandled attribute removed: Pure") @Nonnull public final TimeInterval toTimeStandard(@Nonnull TimeStandard timeStandard) { if (ObjectHelper.referenceEquals(m_start.getStandard(), timeStandard) && ObjectHelper.referenceEquals(m_stop.getStandard(), timeStandard)) { return this; } return new TimeInterval(m_start.toTimeStandard(timeStandard), m_stop.toTimeStandard(timeStandard)); }
@Nonnull private final JulianDate addIgnoringTimeStandard(@Nonnull Duration duration) { int days = getDay() + duration.getDays(); double seconds = getSecondsOfDay() + duration.getSeconds(); return new JulianDate(days, seconds, getStandard()); }
public final Duration subtract(@Nonnull JulianDate subtrahend) { final TimeStandard subtractionTimeStandard = TimeStandard.INTERNATIONAL_ATOMIC_TIME; if (subtractionTimeStandard != getStandard() && subtractionTimeStandard != subtrahend.getStandard()) { if (subtractionTimeStandard != getStandard()) { if (subtractionTimeStandard != subtrahend.getStandard()) {
/** * Converts this date to {@link TimeStandard#INTERNATIONAL_ATOMIC_TIME} (TAI). * @return An equivalent date expressed in TAI. */ @Nonnull public final JulianDate toInternationalAtomicTime() { if (getStandard() == TimeStandard.INTERNATIONAL_ATOMIC_TIME) { return this; } return new JulianDate(getDay(), getSecondsOfDay() + LeapSeconds.getInstance().getTaiMinusUtc(this), TimeStandard.INTERNATIONAL_ATOMIC_TIME); }
if (timeStandard == getStandard()) { result[0] = this; return true; if (timeStandard == TimeStandard.INTERNATIONAL_ATOMIC_TIME && getStandard() == TimeStandard.COORDINATED_UNIVERSAL_TIME) { result[0] = new JulianDate(getDay(), getSecondsOfDay() + LeapSeconds.getInstance().getTaiMinusUtc(this), timeStandard); return true; if (timeStandard == TimeStandard.COORDINATED_UNIVERSAL_TIME && getStandard() == TimeStandard.INTERNATIONAL_ATOMIC_TIME) { return LeapSeconds.getInstance().tryConvertTaiToUtc(this, result);
public final JulianDate add(@Nonnull Duration duration) { final TimeStandard additionTimeStandard = TimeStandard.INTERNATIONAL_ATOMIC_TIME; if (additionTimeStandard != getStandard()) { null }; final boolean temp$2 = resultInAdditionStandard.tryConvertTimeStandard(getStandard(), out$result$3); result = out$result$3[0]; if (temp$2) {
/** * Tests that initialization of and access to the structure time standard element is performed correctly. Also tests that the default time standard is {@link TimeStandard#INTERNATIONAL_ATOMIC_TIME}. */ @Test public final void testTimeStandard() { JulianDate date = new JulianDate(0D); AssertHelper.assertEquals(TimeStandard.INTERNATIONAL_ATOMIC_TIME, date.getStandard()); date = new JulianDate(100, 123.456789012); AssertHelper.assertEquals(TimeStandard.INTERNATIONAL_ATOMIC_TIME, date.getStandard()); date = new JulianDate(100, 123.456789012, TimeStandard.COORDINATED_UNIVERSAL_TIME); AssertHelper.assertEquals(TimeStandard.COORDINATED_UNIVERSAL_TIME, date.getStandard()); }
/** * Returns the value of this {@link JulianDate} in the standard format. * @return The string. */ @Override public String toString() { StringBuilder builder = new StringBuilder(); StringHelper.appendFormat(builder, CultureInfoHelper.getCurrentCulture(), "{0}:{1} ", m_day, m_secondsOfDay); builder.append(getStandard() == TimeStandard.COORDINATED_UNIVERSAL_TIME ? "UTC" : "TAI"); if (JulianDate.lessThan(this, GregorianDate.MinValue.toJulianDate())) { StringHelper.appendFormat(builder, CultureInfoHelper.getCurrentCulture(), " (before {0})", GregorianDate.MinValue); } else if (JulianDate.greaterThan(this, GregorianDate.MaxValue.toJulianDate())) { StringHelper.appendFormat(builder, CultureInfoHelper.getCurrentCulture(), " (after {0})", GregorianDate.MaxValue); } else { StringHelper.appendFormat(builder, CultureInfoHelper.getCurrentCulture(), " ({0})", toGregorianDate()); } return builder.toString(); }
if (date.getStandard() == TimeStandard.INTERNATIONAL_ATOMIC_TIME) { JulianDate lastDate = getDateForIndex(index); JulianDate taiCutoff = new JulianDate(lastDate.getDay(), lastDate.getSecondsOfDay(), TimeStandard.INTERNATIONAL_ATOMIC_TIME);
/** * Tests the {@link JulianDate#addSeconds} method. */ @Test public final void testAddSeconds() { // Make sure AddSeconds produces the correct answer in the correct time standard. JulianDate test = new JulianDate(2451912, 43200.0, TimeStandard.INTERNATIONAL_ATOMIC_TIME); JulianDate result = test.addSeconds(45.123); AssertHelper.assertEquals(TimeStandard.INTERNATIONAL_ATOMIC_TIME, result.getStandard()); Assert.assertEquals((int) 2451912, (int) result.getDay()); Assert.assertEquals(43245.123, result.getSecondsOfDay(), 0d); }
/** * Tests the {@link JulianDate#subtractSeconds} method. */ @Test public final void testSubtractSeconds() { // Make sure SubtractSeconds produces the correct answer in the correct time standard. JulianDate test = new JulianDate(2451912, 0.0, TimeStandard.INTERNATIONAL_ATOMIC_TIME); JulianDate result = test.subtractSeconds(43200.25); AssertHelper.assertEquals(TimeStandard.INTERNATIONAL_ATOMIC_TIME, result.getStandard()); Assert.assertEquals((int) 2451911, (int) result.getDay()); Assert.assertEquals(43199.75, result.getSecondsOfDay(), 0d); }
/** * Tests the {@link JulianDate#addDays} method. */ @Test public final void testAddDays() { // Make sure AddDays produces the correct answer in the correct time standard. JulianDate test = new JulianDate(2451912, 43200.0, TimeStandard.INTERNATIONAL_ATOMIC_TIME); JulianDate result = test.addDays(45.5); AssertHelper.assertEquals(TimeStandard.INTERNATIONAL_ATOMIC_TIME, result.getStandard()); Assert.assertEquals((int) 2451958, (int) result.getDay()); Assert.assertEquals(0.0, result.getSecondsOfDay(), 0d); }
@Test public final void testConstructor() { LeapSecond leapSecond = new LeapSecond(2451545.0, 100.0); Assert.assertEquals(2451545.0, leapSecond.getDate().getTotalDays(), 0d); Assert.assertEquals(100.0, leapSecond.getTotalTaiOffsetFromUtc(), 0d); AssertHelper.assertEquals(TimeStandard.COORDINATED_UNIVERSAL_TIME, leapSecond.getDate().getStandard()); }
null }; final boolean temp$4 = other.tryConvertTimeStandard(getStandard(), out$otherDate$5); otherDate = out$otherDate$5[0]; if (temp$4) {
/** * Tests the {@link TimeInterval#toTimeStandard} method. */ @Test public final void testToTimeStandard() { JulianDate start = new JulianDate(2451545.0, TimeStandard.COORDINATED_UNIVERSAL_TIME); JulianDate stop = new JulianDate(2451546.0, TimeStandard.COORDINATED_UNIVERSAL_TIME); TimeInterval interval = new TimeInterval(start, stop); TimeInterval result = interval.toTimeStandard(TimeStandard.COORDINATED_UNIVERSAL_TIME); AssertHelper.assertEquals(result.getStart().getStandard(), TimeStandard.COORDINATED_UNIVERSAL_TIME); AssertHelper.assertEquals(result.getStop().getStandard(), TimeStandard.COORDINATED_UNIVERSAL_TIME); Assert.assertEquals(result.getStart().getTotalDays(), 2451545.0, Constants.Epsilon15); Assert.assertEquals(result.getStop().getTotalDays(), 2451546.0, Constants.Epsilon15); result = interval.toTimeStandard(TimeStandard.INTERNATIONAL_ATOMIC_TIME); AssertHelper.assertEquals(result.getStart().getStandard(), TimeStandard.INTERNATIONAL_ATOMIC_TIME); AssertHelper.assertEquals(result.getStop().getStandard(), TimeStandard.INTERNATIONAL_ATOMIC_TIME); AssertHelper.assertNotEqual(result.getStart().getTotalDays(), 2451545.0); AssertHelper.assertNotEqual(result.getStop().getTotalDays(), 2451546.0); TimeInterval empty = new TimeInterval(new JulianDate(2451545.0, TimeStandard.COORDINATED_UNIVERSAL_TIME), new JulianDate(2451545.0, TimeStandard.COORDINATED_UNIVERSAL_TIME)); Assert.assertTrue(empty.getIsEmpty()); result = empty.toTimeStandard(TimeStandard.INTERNATIONAL_ATOMIC_TIME); Assert.assertTrue(result.getIsEmpty()); }
@Test public final void testNonStandardTimeStandard() { GregorianDate gregorianDate = new GregorianDate(2008, 12, 31, 23, 59, 40D); JulianDate jd = gregorianDate.toJulianDate(TimeStandard.INTERNATIONAL_ATOMIC_TIME); AssertHelper.assertEquals(TimeStandard.INTERNATIONAL_ATOMIC_TIME, jd.getStandard()); GregorianDate roundTrip1 = jd.toGregorianDate(TimeStandard.INTERNATIONAL_ATOMIC_TIME); AssertHelper.assertEquals(gregorianDate, roundTrip1); GregorianDate roundTrip = new GregorianDate(jd); AssertHelper.assertNotEqual(gregorianDate, roundTrip); double expectedDifference = LeapSeconds.getInstance().getTaiMinusUtc(jd); Assert.assertEquals(expectedDifference, gregorianDate.getSecond() - roundTrip.getSecond(), 0d); }
@Test public final void testTryConvertTimeStandard() { JulianDate leapSecond = new JulianDate(2453736, 43232D, TimeStandard.INTERNATIONAL_ATOMIC_TIME); JulianDate afterLeapSecond = new JulianDate(2453736, 43233D, TimeStandard.INTERNATIONAL_ATOMIC_TIME); @CS2JInfo("Initialization of C# struct variable 'outDate' added by translator.") JulianDate outDate = new JulianDate(); final JulianDate[] out$outDate$0 = { null }; Assert.assertFalse(leapSecond.tryConvertTimeStandard(TimeStandard.COORDINATED_UNIVERSAL_TIME, out$outDate$0)); outDate = out$outDate$0[0]; final JulianDate[] out$outDate$1 = { null }; Assert.assertTrue(afterLeapSecond.tryConvertTimeStandard(TimeStandard.COORDINATED_UNIVERSAL_TIME, out$outDate$1)); outDate = out$outDate$1[0]; AssertHelper.assertEquals(outDate.getStandard(), TimeStandard.COORDINATED_UNIVERSAL_TIME); AssertHelper.assertEquals(outDate, afterLeapSecond); }