/** * Returns a {@link Duration} representing the span of time between the {@code Start} ({@link #getStart get}) and {@code Stop} ({@link #getStop get}) of the interval. * @return The duration. */ @CS2JWarning("Unhandled attribute removed: Pure") @Nonnull public final Duration toDuration() { return JulianDate.subtract(m_stop, m_start); }
@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); }
/** * Subtracts a {@link Duration} from a Julian date, yielding a new {@link JulianDate}. * @param left The minuend. * @param right The subtrahend. * @return A new Julian Date that is the result of the subtraction; that is, {@code left} minus {@code right}. */ @CS2JInfo("This method implements the functionality of the overloaded operator: 'JulianDate -(JulianDate,Duration)'") @Nonnull public static JulianDate subtract(@Nonnull JulianDate left, @Nonnull Duration right) { return left.subtract(right); }
/** * Subtracts a Julian date from another Julian date, yielding a {@link Duration}. * @param left The minuend. * @param right The subtrahend. * @return The Duration that is the result of the subtraction; that is, {@code left} minus {@code right}. The time standard will be the same as the time standard of the subtrahend. */ @CS2JInfo("This method implements the functionality of the overloaded operator: 'Duration -(JulianDate,JulianDate)'") @Nonnull public static Duration subtract(@Nonnull JulianDate left, @Nonnull JulianDate right) { return left.subtract(right); }
/** * Subtracts the specified number of seconds to this date and returns the new date. * @param seconds The number of seconds. * @return The new date. */ @CS2JWarning("Unhandled attribute removed: Pure") @Nonnull public final JulianDate subtractSeconds(double seconds) { return subtract(Duration.fromSeconds(seconds)); }
@Test public final void testConversionToJulianDate() { GregorianDate date = new GregorianDate(2008, 12, 31, 23, 59, 0D); JulianDate julianDate = date.toJulianDate(); GregorianDate oneSecondLater = new GregorianDate(2008, 12, 31, 23, 59, 1D); GregorianDate oneSecondBefore = new GregorianDate(2008, 12, 31, 23, 58, 59D); Assert.assertEquals(1, oneSecondLater.toJulianDate().subtract(julianDate).getSeconds(), 0d); Assert.assertEquals(1, julianDate.subtract(oneSecondBefore.toJulianDate()).getSeconds(), 0d); }
@Test public final void canConvertGregorianDateRepresentingLeapSecondToJulianDate() { GregorianDate leapSecondGregorianDate = new GregorianDate(2008, 12, 31, 23, 59, 60D); JulianDate leapSecondJulianDate = leapSecondGregorianDate.toJulianDate(); AssertHelper.assertEquals(leapSecondGregorianDate, leapSecondJulianDate.toGregorianDate()); GregorianDate oneSecondLater = new GregorianDate(2009, 1, 1, 0, 0, 0D); GregorianDate oneSecondBefore = new GregorianDate(2008, 12, 31, 23, 59, 59D); Assert.assertEquals(1, oneSecondLater.toJulianDate().subtract(leapSecondJulianDate).getSeconds(), 0d); Assert.assertEquals(1, leapSecondJulianDate.subtract(oneSecondBefore.toJulianDate()).getSeconds(), 0d); }
/** * Tests the subtraction operation between Julian dates. */ @Test public final void testSubtraction() { JulianDate first = new JulianDate(2469477, 1000.0); JulianDate second = new JulianDate(2469477, 2000.0); Duration difference = JulianDate.subtract(second, first); Assert.assertEquals(1000.0, difference.getTotalSeconds(), 0d); difference = JulianDate.subtract(first, second); Assert.assertEquals(-1000.0, difference.getTotalSeconds(), 0d); first = new JulianDate(2469477, 1000.0); second = new JulianDate(2469478, 2000.0); difference = JulianDate.subtract(second, first); Assert.assertEquals((int) 1, (int) difference.getDays()); Assert.assertEquals(1000.0, difference.getSeconds(), 0d); difference = JulianDate.subtract(first, second); Assert.assertEquals((int) -1, (int) difference.getDays()); Assert.assertEquals(-1000.0, difference.getSeconds(), 0d); first = new JulianDate(2469477, 86000.0); second = new JulianDate(2469478, 100.0); difference = JulianDate.subtract(second, first); Assert.assertEquals((int) 0, (int) difference.getDays()); Assert.assertEquals(500.0, difference.getSeconds(), 0d); difference = JulianDate.subtract(first, second); Assert.assertEquals((int) 0, (int) difference.getDays()); Assert.assertEquals(-500.0, difference.getSeconds(), 0d); }
/** * 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); }
@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); }
/** * Tests the function that determines the number of seconds between two Julian Dates */ @Test public final void testMinutesDifference() { double totalElapsedTime = TimeConstants.SecondsPerDay * 2.5; double totalElapsedTimeMinutes = totalElapsedTime / TimeConstants.SecondsPerMinute; //Test same time standard, both safe JulianDate first = new JulianDate(2451545.0); JulianDate second = JulianDate.add(first, Duration.fromSeconds(totalElapsedTime)); Assert.assertEquals(totalElapsedTimeMinutes, first.minutesDifference(second), 0d); Assert.assertEquals((JulianDate.subtract(second, first)).getTotalSeconds() / TimeConstants.SecondsPerMinute, first.minutesDifference(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(totalElapsedTimeMinutes, first.minutesDifference(second), 0d); Assert.assertEquals((JulianDate.subtract(second, first)).getTotalSeconds() / TimeConstants.SecondsPerMinute, first.minutesDifference(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(totalElapsedTimeMinutes, first.minutesDifference(secondDiffStandard), 0d); Assert.assertEquals((JulianDate.subtract(secondDiffStandard, first)).getTotalSeconds() / TimeConstants.SecondsPerMinute, first.minutesDifference(secondDiffStandard), 0d); first = JulianDate.getMinValue(); second = JulianDate.getMaxValue(); Assert.assertEquals(((long) Integer.MAX_VALUE - Integer.MIN_VALUE) * TimeConstants.MinutesPerDay, first.minutesDifference(second), 0d); }
/** * Tests the function that determines the number of seconds between two Julian Dates */ @Test public final void testSecondsDifference() { // Test same standard - both safe JulianDate first = new JulianDate(2451545.0); JulianDate second = JulianDate.add(first, Duration.fromSeconds(120000D)); Assert.assertEquals(120000, first.secondsDifference(second), 0d); Assert.assertEquals((JulianDate.subtract(second, first)).getTotalSeconds(), first.secondsDifference(second), 0d); //Test same standard - both unsafe first = new JulianDate(2451545.0, TimeStandard.COORDINATED_UNIVERSAL_TIME); second = JulianDate.add(first, Duration.fromSeconds(120000D)); second = new JulianDate(second.getDay(), second.getSecondsOfDay(), TimeStandard.COORDINATED_UNIVERSAL_TIME); Assert.assertEquals(120000, first.secondsDifference(second), 0d); Assert.assertEquals((JulianDate.subtract(second, first)).getTotalSeconds(), first.secondsDifference(second), 0d); // Test diff standard - one unsafe, one safe first = new JulianDate(2451545.0); second = JulianDate.add(first, Duration.fromSeconds(120000D)); JulianDate secondDiffStandard = second.toTimeStandard(TimeStandard.COORDINATED_UNIVERSAL_TIME); Assert.assertEquals(120000, first.secondsDifference(secondDiffStandard), 0d); Assert.assertEquals((JulianDate.subtract(secondDiffStandard, first)).getTotalSeconds(), first.secondsDifference(secondDiffStandard), 0d); first = JulianDate.getMinValue(); second = JulianDate.getMaxValue(); Assert.assertEquals(((long) Integer.MAX_VALUE - Integer.MIN_VALUE) * TimeConstants.SecondsPerDay, first.secondsDifference(second), 0d); }
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); 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); 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);