/** * Divides the {@link Duration} by another {@link Duration}, yield a constant. * @param divisor The {@link Duration} by which to divide this {@link Duration}. * @return The result of dividing this {@link Duration} by another. */ @CS2JWarning("Unhandled attribute removed: Pure") public final double divide(@Nonnull Duration divisor) { return getTotalSeconds() / divisor.getTotalSeconds(); }
/** * Returns {@code true} if this {@link Duration} is within {@code epsilon} seconds of the specified {@link Duration}. That is, in order for the {@link Duration Durations} to be considered equal (and for this function to return {@code true}), the absolute value of the difference between them, in seconds, must be less than or equal to {@code epsilon}. * @param other The {@link Duration} to compare to this {@link Duration}. * @param epsilon The largest difference between the {@link Duration Durations}, in seconds, such that they will be considered equal. * @return {@code true} if the dates are equal as defined by the epsilon value. */ @CS2JWarning("Unhandled attribute removed: Pure") public final boolean equalsEpsilon(@Nonnull Duration other, double epsilon) { return Math.abs(subtract(other).getTotalSeconds()) <= epsilon; }
/** * Writes the amount of time to extrapolate forward before the property becomes undefined. A value of 0 will extrapolate forever. * @param duration The duration. */ public final void writeForwardExtrapolationDuration(@Nonnull Duration duration) { openIntervalIfNecessary(); getOutput().writePropertyName("forwardExtrapolationDuration"); getOutput().writeValue(duration.getTotalSeconds()); }
/** * Writes the amount of time to extrapolate backward before the property becomes undefined. A value of 0 will extrapolate forever. * @param duration The duration. */ public final void writeBackwardExtrapolationDuration(@Nonnull Duration duration) { openIntervalIfNecessary(); getOutput().writePropertyName("backwardExtrapolationDuration"); getOutput().writeValue(duration.getTotalSeconds()); } }
/** * Tests that {@code MinValue} ({@link Duration#getMinValue get}), {@code MaxValue} ({@link Duration#getMaxValue get}), and {@code Zero} ({@link Duration#getZero get}) can be constructed as claimed. */ @Test public final void testMinValueMaxValueZeroValue() { Duration min = Duration.fromSeconds(Duration.getMinValue().getTotalSeconds()); Assert.assertEquals((int) Integer.MIN_VALUE, (int) min.getDays()); Assert.assertEquals(0.0, min.getSeconds(), 0d); Duration max = Duration.fromSeconds(Duration.getMaxValue().getTotalSeconds()); Assert.assertEquals((int) Integer.MAX_VALUE, (int) max.getDays()); Assert.assertEquals(0.0, max.getSeconds(), 0d); Duration zero = Duration.fromSeconds(Duration.getZero().getTotalSeconds()); Assert.assertEquals(0.0, zero.getDays(), 0d); Assert.assertEquals(0.0, zero.getSeconds(), 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 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); }
Duration second = new Duration(5, 2000.0); Duration difference = Duration.subtract(second, first); Assert.assertEquals(1000.0, difference.getTotalSeconds(), 0d); difference = Duration.subtract(first, second); Assert.assertEquals(-1000.0, difference.getTotalSeconds(), 0d); first = new Duration(5, 1000.0); second = new Duration(6, 2000.0);
/** * 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); }