/** * Adds a {@link Duration} to a {@link JulianDate}, producing a new Julian date. * @param left The Julian date. * @param right The duration. * @return A new Julian Date that is the result of the addition. */ @CS2JInfo("This method implements the functionality of the overloaded operator: 'JulianDate +(JulianDate,Duration)'") @Nonnull public static JulianDate add(@Nonnull JulianDate left, @Nonnull Duration right) { return left.add(right); }
/** * Adds 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 addSeconds(double seconds) { return add(Duration.fromSeconds(seconds)); }
/** * Adds the specified number of days to this date and returns the new date. * @param days The number of days. * @return The new date. */ @CS2JWarning("Unhandled attribute removed: Pure") @Nonnull public final JulianDate addDays(double days) { return add(Duration.fromDays(days)); }
@Nonnull private final GregorianDate rolloverTime(double days, double hours, double minutes, double seconds, @Nonnull TimeStandard timeStandard) { int wholeDays = (int) days; seconds += (days - wholeDays) * TimeConstants.SecondsPerDay; int wholeHours = (int) hours; seconds += (hours - wholeHours) * TimeConstants.SecondsPerHour; int wholeMinutes = (int) minutes; seconds += (minutes - wholeMinutes) * TimeConstants.SecondsPerMinute; Duration timeToAdd = new Duration(wholeDays, wholeHours, wholeMinutes, seconds); JulianDate julianResult = toJulianDate(timeStandard).add(timeToAdd); return new GregorianDate(julianResult, timeStandard); }
/** * Subtracts a {@link Duration} from this Julian date, producing a new Julian date. * @param duration The duration to subtract. * @return A new {@link JulianDate} that is the result of the subtraction. */ @CS2JWarning("Unhandled attribute removed: Pure") @Nonnull public final JulianDate subtract(@Nonnull Duration duration) { return add(new Duration(-duration.getDays(), -duration.getSeconds())); }
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;
/** * Tests that the Duration of an Interval is calculated correctly. */ @Test public final void testCalculateDuration() { JulianDate start = new JulianDate(2451545.0); JulianDate stop = JulianDate.add(start, Duration.fromDays(1.5)); TimeInterval interval = new TimeInterval(start, stop); AssertHelper.assertEquals(Duration.fromDays(1.5), interval.toDuration()); }
/** * Tests that initialization of and access to the type's values is performed correctly. */ @Test public final void testRetainValue() { JulianDate start = new JulianDate(DateTimeHelper.utcNow()); JulianDate stop = JulianDate.add(start, Duration.fromDays(1.5)); TimeInterval interval = new TimeInterval(start, stop); AssertHelper.assertEquals(start, interval.getStart()); AssertHelper.assertEquals(stop, interval.getStop()); }
/** * 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); }
/** * 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 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); }
@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 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); }
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); 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); 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);