/** * 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); }
date = date.toTimeStandard(TimeStandard.COORDINATED_UNIVERSAL_TIME); LeapSecond toFind = new LeapSecond(date, 0.0); if (date.getStandard() == TimeStandard.INTERNATIONAL_ATOMIC_TIME) { JulianDate lastDate = getDateForIndex(index); JulianDate taiCutoff = new JulianDate(lastDate.getDay(), lastDate.getSecondsOfDay(), TimeStandard.INTERNATIONAL_ATOMIC_TIME); taiCutoff = JulianDate.add(taiCutoff, Duration.fromSeconds(getOffsetForIndex(index))); if (JulianDate.lessThan(date, taiCutoff)) { --index;
@Test public final void testSecondsDifferenceAtLeapSecond() { JulianDate leapSecond = new JulianDate(2453736, 43232D, TimeStandard.INTERNATIONAL_ATOMIC_TIME); JulianDate utcDate = new JulianDate(2453736, 43232D, TimeStandard.COORDINATED_UNIVERSAL_TIME); Assert.assertEquals(-33, utcDate.secondsDifference(leapSecond), 0d); Assert.assertEquals(33, leapSecond.secondsDifference(utcDate), 0d); JulianDate secondBeforeLeapSecondUTC = leapSecond.subtractSeconds(1D).toTimeStandard(TimeStandard.COORDINATED_UNIVERSAL_TIME); JulianDate secondAfterLeapSecondUTC = leapSecond.addSeconds(1D).toTimeStandard(TimeStandard.COORDINATED_UNIVERSAL_TIME); Assert.assertEquals(2, secondBeforeLeapSecondUTC.secondsDifference(secondAfterLeapSecondUTC), 0d); Assert.assertEquals(2, secondAfterLeapSecondUTC.subtract(secondBeforeLeapSecondUTC).getSeconds(), 0d); }
@Nonnull private final Duration subtractIgnoringTimeStandard(@Nonnull JulianDate subtrahend) { int days = getDay() - subtrahend.getDay(); double seconds = getSecondsOfDay() - subtrahend.getSecondsOfDay(); return new Duration(days, seconds); }
/** * Computes the number of minutes that have elapsed from this Julian date to the {@code other} Julian date. * <p> This method subtracts the Julian date on which it is called from the {@code 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 {@code other} Julian date should have the same time standard and it should be safe for arithmetic. * @param other The other Julian date, which is the end of the interval. * @return The number of minutes that have elapsed from this Julian date to the other Julian date. */ @CS2JWarning("Unhandled attribute removed: Pure") public final double minutesDifference(@Nonnull JulianDate other) { JulianDate start = toInternationalAtomicTime(); JulianDate end = other.toInternationalAtomicTime(); long startDay = start.getDay(); long endDay = end.getDay(); return (endDay - startDay) * TimeConstants.MinutesPerDay + (end.getSecondsOfDay() - start.getSecondsOfDay()) / TimeConstants.SecondsPerMinute; }
@Test public final void testDaysDifference() { double totalElapsedTime = TimeConstants.SecondsPerDay * 2.5; double totalElapsedTimeDays = totalElapsedTime / TimeConstants.SecondsPerDay; //Test same time standard, both safe JulianDate first = new JulianDate(2451545.0); JulianDate second = JulianDate.add(first, Duration.fromSeconds(totalElapsedTime)); Assert.assertEquals(totalElapsedTimeDays, first.daysDifference(second), 0d); Assert.assertEquals((JulianDate.subtract(second, first)).getTotalSeconds() / TimeConstants.SecondsPerDay, first.daysDifference(second), 0d); //Test same time standard, both unsafe first = new JulianDate(2451545.0, TimeStandard.COORDINATED_UNIVERSAL_TIME); second = JulianDate.add(first, Duration.fromSeconds(totalElapsedTime)); second = new JulianDate(second.getDay(), second.getSecondsOfDay(), TimeStandard.COORDINATED_UNIVERSAL_TIME); Assert.assertEquals(totalElapsedTimeDays, first.daysDifference(second), 0d); Assert.assertEquals((JulianDate.subtract(second, first)).getTotalSeconds() / TimeConstants.SecondsPerDay, first.daysDifference(second), 0d); //Test diff time standard, one safe, one unsafe first = new JulianDate(2451545.0); second = JulianDate.add(first, Duration.fromSeconds(totalElapsedTime)); JulianDate secondDiffStandard = second.toTimeStandard(TimeStandard.COORDINATED_UNIVERSAL_TIME); Assert.assertEquals(totalElapsedTimeDays, first.daysDifference(secondDiffStandard), 0d); Assert.assertEquals((JulianDate.subtract(secondDiffStandard, first)).getTotalSeconds() / TimeConstants.SecondsPerDay, first.daysDifference(secondDiffStandard), 0d); first = JulianDate.getMinValue(); second = JulianDate.getMaxValue(); Assert.assertEquals((long) Integer.MAX_VALUE - Integer.MIN_VALUE, first.daysDifference(second), 0d); }
int isClose = isClose(other); if (isClose != 0) { return isClose; JulianDate self = new JulianDate(); @CS2JInfo("Initialization of C# struct variable 'otherDate' added by translator.") JulianDate otherDate = new JulianDate(); final JulianDate[] out$otherDate$5 = { null }; final boolean temp$4 = other.tryConvertTimeStandard(getStandard(), out$otherDate$5); otherDate = out$otherDate$5[0]; if (temp$4) { } else { self = toInternationalAtomicTime(); otherDate = other.toInternationalAtomicTime(); if (self.getDay() != otherDate.getDay()) { return self.getDay() < otherDate.getDay() ? -1 : 1; if (self.getSecondsOfDay() != otherDate.getSecondsOfDay()) { return self.getSecondsOfDay() < otherDate.getSecondsOfDay() ? -1 : 1;
/** * Tests that initialization produces a {@link JulianDate} which is normalized with the time element in the range 0.0 <= seconds < 86400.0. */ @Test public final void testTimeGreaterThanADay() { JulianDate date = new JulianDate(2451545, 107000.0); Assert.assertEquals((int) 2451546, (int) date.getDay()); Assert.assertEquals(20600.0, date.getSecondsOfDay(), 0d); date = new JulianDate(2451545, 107000.0, TimeStandard.INTERNATIONAL_ATOMIC_TIME); Assert.assertEquals((int) 2451546, (int) date.getDay()); Assert.assertEquals(20600.0, date.getSecondsOfDay(), 0d); }
boolean isLeapSecond = false; @CS2JInfo("Initialization of C# struct variable 'convertedJulianDate' added by translator.") JulianDate convertedJulianDate = new JulianDate(); final JulianDate[] out$convertedJulianDate$110 = { null }; final boolean temp$109 = julianDate.tryConvertTimeStandard(timeStandard, out$convertedJulianDate$110); convertedJulianDate = out$convertedJulianDate$110[0]; if (!temp$109) { isLeapSecond = true; convertedJulianDate = julianDate.subtractSeconds(1D).toTimeStandard(timeStandard); double secondsOfDay = convertedJulianDate.getSecondsOfDay(); m_hour = (int) Math.floor(secondsOfDay / SecondsPerHour); double remainingSeconds = secondsOfDay - m_hour * SecondsPerHour;
public final boolean tryConvertTaiToUtc(@Nonnull JulianDate date, @Nonnull JulianDate[] result) { LeapSecond toFind = new LeapSecond(date.getTotalDays(), 0.0); int index = Collections.binarySearch(m_leapSeconds, toFind, s_leapSecondComparer); if (index < 0) { double mostRecentOffset = getOffsetForIndex(index); JulianDate leapSecondDate = getDateForIndex(index); if (date.getDay() == leapSecondDate.getDay()) { double secondsSinceLeapSecond = date.getSecondsOfDay() - leapSecondDate.getSecondsOfDay(); if (secondsSinceLeapSecond >= mostRecentOffset - 1 && secondsSinceLeapSecond < mostRecentOffset) { result[0] = JulianDate.getMinValue(); return false; result[0] = new JulianDate(date.getDay(), date.getSecondsOfDay() - getOffsetForIndex(index), TimeStandard.COORDINATED_UNIVERSAL_TIME); return true;
JulianDate original = new JulianDate(2460000, 1000.0); Duration toAdd = Duration.fromSeconds(50.0); JulianDate added = original.add(toAdd); Assert.assertEquals((int) 2460000, (int) added.getDay()); Assert.assertEquals(1050.0, added.getSecondsOfDay(), 0d); JulianDate subtracted = original.subtract(toAdd); Assert.assertEquals((int) 2460000, (int) subtracted.getDay()); Assert.assertEquals(950.0, subtracted.getSecondsOfDay(), 0d); original = new JulianDate(2460000, 8382.1); toAdd = new Duration(1, 10.0); added = JulianDate.add(original, toAdd); Assert.assertEquals((int) 2460001, (int) added.getDay()); Assert.assertEquals(8392.1, added.getSecondsOfDay(), 0d); subtracted = JulianDate.subtract(original, toAdd); Assert.assertEquals((int) 2459999, (int) subtracted.getDay()); Assert.assertEquals(8372.1, subtracted.getSecondsOfDay(), 0d); original = new JulianDate(2460000, 86000.0); toAdd = Duration.fromSeconds(1000.0); added = original.add(toAdd); Assert.assertEquals((int) 2460001, (int) added.getDay()); Assert.assertEquals(600.0, added.getSecondsOfDay(), 0d); subtracted = original.subtract(toAdd); Assert.assertEquals((int) 2460000, (int) subtracted.getDay()); Assert.assertEquals(85000.0, subtracted.getSecondsOfDay(), 0d);
public final JulianDate add(@Nonnull Duration duration) { final TimeStandard additionTimeStandard = TimeStandard.INTERNATIONAL_ATOMIC_TIME; if (additionTimeStandard != getStandard()) { JulianDate resultInAdditionStandard = toInternationalAtomicTime().addIgnoringTimeStandard(duration); JulianDate result = new JulianDate(); final JulianDate[] out$result$3 = { null }; final boolean temp$2 = resultInAdditionStandard.tryConvertTimeStandard(getStandard(), out$result$3); result = out$result$3[0]; if (temp$2) { return addIgnoringTimeStandard(duration);
/** * Convert this {@link GregorianDate} to a {@link JulianDate}. The {@link GregorianDate} is assumed to specify a time in the specified {@link TimeStandard}. * @param timeStandard The time standard in which this {@link GregorianDate} is expressed. The returned {@link JulianDate} will be expressed in this time standard as well, if possible. * @return A {@link JulianDate} representing this date. */ @CS2JWarning("Unhandled attribute removed: Pure") @Nonnull public final JulianDate toJulianDate(@Nonnull TimeStandard timeStandard) { int julianDayNumber = m_yearMonthDay.getJulianDayNumber(); double julianSecondsOfDay = getJulianSecondsOfDay(); if (getIsLeapSecond()) { julianSecondsOfDay -= 1D; } else if (julianSecondsOfDay >= 43200.0) { julianDayNumber -= 1; } JulianDate result = new JulianDate(julianDayNumber, julianSecondsOfDay, timeStandard); if (getIsLeapSecond()) { result = result.addSeconds(1D); } return result; }
/** * 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(); }
/** * Converts two Julian dates in TAI to UTC: one just before a leap second, and one after a leap second. Verifies that they convert to different UTC Julian dates. */ @Test public final void testTaiToUtcNearLeapSecond() { LeapSeconds leapSeconds = new LeapSeconds(); LeapSeconds.setInstance(leapSeconds); JulianDate momentOfLeapSecond = new JulianDate(2453736, 43232.0, TimeStandard.INTERNATIONAL_ATOMIC_TIME); JulianDate before = JulianDate.subtract(momentOfLeapSecond, Duration.fromSeconds(1.0)); JulianDate after = JulianDate.add(momentOfLeapSecond, Duration.fromSeconds(1.0)); JulianDate beforeUtc = before.toTimeStandard(TimeStandard.COORDINATED_UNIVERSAL_TIME); JulianDate afterUtc = after.toTimeStandard(TimeStandard.COORDINATED_UNIVERSAL_TIME); AssertHelper.assertNotEqual(beforeUtc, afterUtc); }
/** * Tests the check for EXACT equality and the check for equality within a specified tolerance. */ @Test public final void testEquality() { JulianDate first = new JulianDate(2451545, 0.2); JulianDate second = new JulianDate(2451545, 0.2); AssertHelper.assertEquals(first, second); Assert.assertTrue(first.equalsType(second)); Assert.assertTrue(second.equalsType(first)); Assert.assertEquals((int) 0, (int) first.compareTo(second)); Assert.assertEquals((int) 0, (int) second.compareTo(first)); AssertHelper.assertNotEqual(first, 5); first = new JulianDate(2451545, 0.00001); second = new JulianDate(2451544, 86399.99999); AssertHelper.assertNotEqual(first, second); Assert.assertFalse(first.equalsType(second)); Assert.assertFalse(second.equalsType(first)); AssertHelper.assertNotEqual(0, first.compareTo(second)); AssertHelper.assertNotEqual(0, second.compareTo(first)); Assert.assertTrue(first.equalsEpsilon(second, 1e-4)); Assert.assertTrue(second.equalsEpsilon(first, 1e-4)); }
dates.add(m_startDate); values.add(new Cartesian(1.0, 2.0, 3.0)); dates.add(m_startDate.addSeconds(60.0)); values.add(new Cartesian(4.0, 5.0, 6.0)); dates.add(m_startDate.addSeconds(120.0)); values.add(new Cartesian(7.0, 8.0, 9.0)); customPropertyWriter.writeCartesian(dates, values);
@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); }
/** * Tests that adding small values to a UTC Julian date does not result in getting stuck when crossing a leap second. */ @Test public final void testUtcAddNotStuckAtLeapSecond() { LeapSeconds leapSeconds = new LeapSeconds(); LeapSeconds.setInstance(leapSeconds); JulianDate date = new JulianDate(2453736, 43198.0, TimeStandard.COORDINATED_UNIVERSAL_TIME); JulianDate after = new JulianDate(2453736, 43202.0, TimeStandard.COORDINATED_UNIVERSAL_TIME); int i; for (i = 0; i < 100; ++i) { date = JulianDate.add(date, Duration.fromSeconds(0.1)); if (JulianDate.greaterThan(date, after)) { break; } } //5 second difference, so 50 additions of a tenth of a second each Assert.assertEquals((int) 50, (int) i); }
/** * 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()); }