/** * 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())); }
/** * Adds a specified number of days to this {@link Duration} and returns the new {@link Duration}. * @param days The number of days to add. * @return A new {@link Duration} which is the sum of the original {@link Duration} and the specified number of days. */ @CS2JWarning("Unhandled attribute removed: Pure") @Nonnull public final Duration addDays(double days) { return add(fromDays(days)); }
/** * Returns {@code true} if {@code left} is longer than or exactly equal to {@code right}. * @param left The left {@link Duration}. * @param right The right {@link Duration}. * @return {@code true} if left is greater than or equal to right, otherwise {@code false}. */ @CS2JInfo("This method implements the functionality of the overloaded operator: 'System.Boolean >=(Duration,Duration)'") public static boolean greaterThanOrEqual(@Nonnull Duration left, @Nonnull Duration right) { return left.compareTo(right) >= 0; }
/** * Adds a specified number of seconds to this {@link Duration} and returns the new {@link Duration}. * @param seconds The number of seconds to add. * @return A new {@link Duration} which is the sum of the original {@link Duration} and the specified number of seconds. */ @CS2JWarning("Unhandled attribute removed: Pure") @Nonnull public final Duration addSeconds(double seconds) { return add(fromSeconds(seconds)); }
/** * 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); }
/** * Tests the addition operation between two {@link Duration} instances with unspecified time standards. */ @Test public final void testAddition() { Duration original = new Duration(5, 1000.0); Duration add = Duration.fromSeconds(50.0); Duration result = Duration.add(original, add); Assert.assertEquals((int) 5, (int) result.getDays()); Assert.assertEquals(1050.0, result.getSeconds(), 0d); original = new Duration(5, 8382.1); add = new Duration(1, 10.0); result = Duration.add(original, add); Assert.assertEquals((int) 6, (int) result.getDays()); Assert.assertEquals(8392.1, result.getSeconds(), 0d); original = new Duration(5, 86000.0); add = Duration.fromSeconds(1000.0); result = Duration.add(original, add); Assert.assertEquals((int) 6, (int) result.getDays()); Assert.assertEquals(600.0, result.getSeconds(), 0d); }
Duration first = new Duration(5, 1000.0); 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); difference = Duration.subtract(second, first); Assert.assertEquals((int) 1, (int) difference.getDays()); Assert.assertEquals(1000.0, difference.getSeconds(), 0d); difference = Duration.subtract(first, second); Assert.assertEquals((int) -1, (int) difference.getDays()); Assert.assertEquals(-1000.0, difference.getSeconds(), 0d); first = new Duration(5, 86000.0); second = new Duration(6, 100.0); difference = Duration.subtract(second, first); Assert.assertEquals((int) 0, (int) difference.getDays()); Assert.assertEquals(500.0, difference.getSeconds(), 0d); difference = Duration.subtract(first, second); Assert.assertEquals((int) 0, (int) difference.getDays()); Assert.assertEquals(-500.0, difference.getSeconds(), 0d);
Duration duration = new Duration(500, 100.0); Duration result = duration.divide(100.0); Assert.assertTrue(result.equalsEpsilon(new Duration(5, 1.0), Constants.Epsilon10)); result = Duration.divide(duration, 100.0); Assert.assertTrue(result.equalsEpsilon(new Duration(5, 1.0), Constants.Epsilon10)); duration = new Duration(5, 68010.0); result = duration.divide(100.0); Assert.assertTrue(result.equalsEpsilon(new Duration(0, 5000.1), Constants.Epsilon10)); result = Duration.divide(duration, 100.0); Assert.assertTrue(result.equalsEpsilon(new Duration(0, 5000.1), Constants.Epsilon10)); duration = new Duration(0, 64800.0); result = duration.divide(0.5); Assert.assertTrue(result.equalsEpsilon(new Duration(1, 43200.0), Constants.Epsilon10)); result = Duration.divide(duration, 0.5); Assert.assertTrue(result.equalsEpsilon(new Duration(1, 43200.0), Constants.Epsilon10)); duration = new Duration(502, 43300.5); result = duration.divide(100.5); Assert.assertTrue(result.equalsEpsilon(new Duration(5, 1.0), Constants.Epsilon10)); result = Duration.divide(duration, 100.5); Assert.assertTrue(result.equalsEpsilon(new Duration(5, 1.0), Constants.Epsilon10)); duration = new Duration(5, 1.0); result = Duration.divide(duration, -2.0); Assert.assertTrue(result.equalsEpsilon(new Duration(-2, -43200.5), Constants.Epsilon10)); duration = new Duration(0, 18 * 3600); result = Duration.divide(duration, -0.5); Assert.assertEquals(-12 * 3600, result.getSeconds(), 0d); Assert.assertEquals((int) -1, (int) result.getDays()); duration = new Duration(1, 4 * 3600); result = Duration.divide(duration, -2D);
Duration duration = new Duration(5, 1.0); Duration result = duration.multiply(100.0); Assert.assertTrue(result.equalsEpsilon(new Duration(500, 100.0), Constants.Epsilon10)); result = Duration.multiply(duration, 100.0); Assert.assertTrue(result.equalsEpsilon(new Duration(500, 100.0), Constants.Epsilon10)); duration = new Duration(0, 5000.1); result = duration.multiply(100.0); Assert.assertTrue(result.equalsEpsilon(new Duration(5, 68010.0), Constants.Epsilon10)); result = Duration.multiply(duration, 100.0); Assert.assertTrue(result.equalsEpsilon(new Duration(5, 68010.0), Constants.Epsilon10)); duration = new Duration(1, 43200.0); result = duration.multiply(0.5); Assert.assertTrue(result.equalsEpsilon(new Duration(0, 64800.0), Constants.Epsilon10)); result = Duration.multiply(duration, 0.5); Assert.assertTrue(result.equalsEpsilon(new Duration(0, 64800.0), Constants.Epsilon10)); duration = new Duration(5, 1.0); result = duration.multiply(100.5); Assert.assertTrue(result.equalsEpsilon(new Duration(502, 43300.5), Constants.Epsilon10)); result = Duration.multiply(duration, 100.5); Assert.assertTrue(result.equalsEpsilon(new Duration(502, 43300.5), Constants.Epsilon10)); result = Duration.multiply(duration, -0.5); Assert.assertTrue(result.equalsEpsilon(new Duration(-2, -43200.5), Constants.Epsilon10)); duration = new Duration(0, 18 * 3600); result = Duration.multiply(duration, -2D); Assert.assertEquals(-12 * 3600, result.getSeconds(), 0d); Assert.assertEquals((int) -1, (int) result.getDays()); duration = new Duration(1, 4 * 3600); result = Duration.multiply(duration, -0.5); Assert.assertEquals(-14 * 3600, result.getSeconds(), 0d);
Duration first = new Duration(5, 565.0); Duration second = new Duration(5, 565.0); AssertHelper.assertEquals(first, second); Assert.assertTrue(first.equalsType(second)); Assert.assertTrue(second.equalsType(first)); Assert.assertTrue(Duration.equals(first, second)); Assert.assertTrue(Duration.equals(second, first)); Assert.assertFalse(Duration.notEquals(first, second)); Assert.assertFalse(Duration.notEquals(second, first)); Assert.assertEquals((int) 0, (int) first.compareTo(second)); Assert.assertEquals((int) 0, (int) second.compareTo(first)); first = new Duration(5, 0.00001); second = new Duration(4, 86399.99999); AssertHelper.assertNotEqual(first, second); Assert.assertFalse(first.equalsType(second)); Assert.assertFalse(second.equalsType(first)); Assert.assertFalse(Duration.equals(first, second)); Assert.assertFalse(Duration.equals(second, first)); Assert.assertTrue(Duration.notEquals(first, second)); Assert.assertTrue(Duration.notEquals(second, 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)); Assert.assertFalse(first.equals(5));
/** * Tests Duration.CompareTo */ @Test public final void testCompareTo() { Duration duration1 = new Duration(1, 0.0); Duration duration2 = new Duration(1, 0.0); Assert.assertTrue(duration1.compareTo(duration2) == 0); Assert.assertTrue(duration2.compareTo(duration1) == 0); Assert.assertTrue(Duration.greaterThanOrEqual(duration1, duration2)); Assert.assertTrue(Duration.lessThanOrEqual(duration2, duration1)); Assert.assertTrue(Duration.lessThanOrEqual(duration1, duration2)); Assert.assertTrue(Duration.greaterThanOrEqual(duration2, duration1)); duration2 = new Duration(2, 0.0); Assert.assertTrue(duration1.compareTo(duration2) < 0); Assert.assertTrue(duration2.compareTo(duration1) > 0); Assert.assertTrue(Duration.lessThan(duration1, duration2)); Assert.assertTrue(Duration.greaterThan(duration2, duration1)); Assert.assertTrue(Duration.lessThanOrEqual(duration1, duration2)); Assert.assertTrue(Duration.greaterThanOrEqual(duration2, duration1)); duration2 = new Duration(1, 1.0); Assert.assertTrue(duration1.compareTo(duration2) < 0); Assert.assertTrue(duration2.compareTo(duration1) > 0); Assert.assertTrue(Duration.lessThan(duration1, duration2)); Assert.assertTrue(Duration.greaterThan(duration2, duration1)); Assert.assertTrue(Duration.lessThanOrEqual(duration1, duration2)); Assert.assertTrue(Duration.greaterThanOrEqual(duration2, duration1)); }
/** * Tests the Duration.AddDays method. */ @Test public final void testAddDays() { Duration test = new Duration(5, 43200.0); Duration result = test.addDays(45.5); Assert.assertEquals((int) 51, (int) result.getDays()); Assert.assertEquals(0.0, result.getSeconds(), 0d); }
/** * Tests the Duration.AddSeconds method. */ @Test public final void testAddSeconds() { Duration test = new Duration(5, 43200.0); Duration result = test.addSeconds(45.123); Assert.assertEquals((int) 5, (int) result.getDays()); Assert.assertEquals(43245.123, result.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 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); }
/** * Returns a {@link Duration} that represents the specified number of days. * @param days The number of days to be represented by the returned {@link Duration}. * @return A {@link Duration} representing the specified number of days. */ @Nonnull public static Duration fromDays(double days) { int wholeDays = (int) days; double seconds = (days - wholeDays) * TimeConstants.SecondsPerDay; return new Duration(wholeDays, seconds); }
/** * 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; }
/** * 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)); }
@Nonnull private final JulianDate addIgnoringTimeStandard(@Nonnull Duration duration) { int days = getDay() + duration.getDays(); double seconds = getSecondsOfDay() + duration.getSeconds(); return new JulianDate(days, seconds, getStandard()); }
/** * Tests division of a {@link Duration} by another. */ @Test public final void testDivisionByDuration() { Duration one = new Duration(1, 0.0); Duration two = new Duration(0, 60.0); Assert.assertEquals(86400.0 / 60.0, one.divide(two), Constants.Epsilon10); Assert.assertEquals(60 / 86400.0, Duration.divide(two, one), Constants.Epsilon10); Duration three = new Duration(1, 43200.0); Assert.assertEquals((86400 + 43200) / 60.0, Duration.divide(three, two), Constants.Epsilon10); Assert.assertEquals(60.0 / (86400.0 + 43200.0), two.divide(three), Constants.Epsilon10); Duration four = new Duration(1, 0D); Duration five = new Duration(0, -3600D); Assert.assertEquals(-24D, Duration.divide(four, five), Constants.Epsilon10); Assert.assertEquals(-1.0 / 24.0, Duration.divide(five, four), Constants.Epsilon10); Duration six = new Duration(-2, 0D); Assert.assertEquals(-0.5, Duration.divide(four, six), 0d); Assert.assertEquals(48, Duration.divide(six, five), 0d); Duration seven = new Duration(0, -0.5); Assert.assertEquals(-48 * 3600, Duration.divide(four, seven), 0d); }