merged master into develop

src/main/java/org/orekit/rugged/utils/AbsoluteDateArrayHandling.java

+/* Copyright 2013-2022 CS GROUP
+ * Licensed to CS GROUP (CS) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * CS licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.orekit.rugged.utils;
+
+import org.hipparchus.exception.LocalizedCoreFormats;
+import org.orekit.errors.OrekitException;
+import org.orekit.time.AbsoluteDate;
+
+/** AbsoluteDateArrayHandling consist of additions to AbsoluteDate to handle arrays.
+ * @author Melina Vanel
+ */
+public class AbsoluteDateArrayHandling {
+
+    /** Dates array on which we want to apply time shift or compute duration. */
+    private final AbsoluteDate[] dates;
+
+    /** Simple constructor.
+     * @param dates is an array of absolute dates on which we want to apply time shift or
+     * compute duration
+     */
+    public AbsoluteDateArrayHandling(final AbsoluteDate[] dates) {
+        this.dates = dates.clone();
+    }
+
+    /** Get instance dates array.
+     * @return dates array
+     */
+    public AbsoluteDate[] getDates() {
+        return this.dates.clone();
+    }
+
+    /** Get time-shifted dates for several dates or several time shifts.
+     * If instance dates = [date1, date2, ..., daten] and argument
+     * dts = [dts1, dts2, ..., dtsn] then this function will return a matrix
+     * [[date1 shiftedby dts1, date1 shiftedBy dts2, ..., date1 shiftedBy dtsn],
+     * [date2 shiftedby dts1, date2 shiftedBy dts2, ..., date2 shiftedBy dtsn],
+     * [...]
+     * [daten shiftedby dts1, daten shiftedBy dts2, ..., date1 shiftedBy dtsn]].
+     * If ones want to apply only 1 time shift corresponding to 1 date see
+     * {@link #shiftedBy(double[])}.
+     * @param dts time shifts array in seconds we want to apply to dates
+     * @return a matrix of new dates, shifted with respect to wanted time
+     * shifts. If instance dates = [date1, date2, ..., daten] each line
+     * correspond to one date (for example date1 shiftedBy all timeshifts
+     * (building the different columns))
+     */
+    public AbsoluteDate[][] multipleShiftedBy(final double[] dts) {
+
+        final AbsoluteDate[][] datesShifted = new AbsoluteDate[dates.length][dts.length];
+        int index_dates = 0;
+
+        for (AbsoluteDate date: this.dates) {
+            final AbsoluteDate[] dateShifted = new AbsoluteDate[dts.length];
+            int index_dts = 0;
+            for (double dt: dts) {
+                dateShifted[index_dts] = date.shiftedBy(dt);
+                index_dts += 1;
+            }
+            datesShifted[index_dates] = dateShifted;
+            index_dates += 1;
+
+        }
+        return (AbsoluteDate[][]) datesShifted;
+    }
+
+    /** Get time-shifted dates for several dates and corresponding time shifts.
+     * If instance dates = [date1, date2, ..., daten] and argument
+     * dts = [dts1, dts2, ..., dtsn] then this function will return
+     * [date1 shiftedby dts1, date2 shiftedBy dts2, ..., daten shiftedBy dtsn]. If
+     * several time shift want to be applied on each date see
+     * {@link #multipleShiftedBy(double[])}.
+     * @param dts time shifts array in seconds we want to apply to corresponding dates.
+     * Warning, must be same length as dates.
+     * @return an 1D array of new dates, shifted with respect to wanted corresponding time
+     * shifts.
+     */
+    public AbsoluteDate[] shiftedBy(final double[] dts) {
+
+        // Check same dimensions
+        if (dates.length != dts.length) {
+            throw new OrekitException(LocalizedCoreFormats.DIMENSIONS_MISMATCH,
+                                      dates.length, dts.length);
+        }
+
+        final AbsoluteDate[] datesShifted = new AbsoluteDate[dates.length];
+        int index_dates = 0;
+
+        for (AbsoluteDate date: this.dates) {
+            datesShifted[index_dates] = date.shiftedBy(dts[index_dates]);
+            index_dates += 1;
+
+        }
+        return datesShifted;
+    }
+
+    /** Get array with durations between instances dates and given dates
+     * If instance dates = [date1, date2, ..., daten] and argument
+     * datesForDuration = [d1, d2, ..., dn] then this function will return a matrix
+     * [[date1 durationFrom d1, date1 durationFrom d2, ..., date1 durationFrom dn],
+     * [date2 durationFrom d1, date2 durationFrom d2, ..., date2 durationFrom dn],
+     * [...]
+     * [daten durationFrom d1, daten durationFrom d2, ..., date1 durationFrom dn]].
+     * If ones want to compute duration from only 1 date corresponding to 1 instance date see
+     * {@link #durationFrom(AbsoluteDate[])}.
+     * @param datesForDuration dates for which we want to compute the duration form instances dates
+     * @return a matrix of double representing durations from instance dates
+     * If instance dates = [date1, date2, ..., daten] each line
+     * correspond to one date (for example date1 duration from all given dates in arguments
+     * (building the different columns))
+     */
+    public double[][] multipleDurationFrom(final AbsoluteDate[] datesForDuration) {
+
+        final double[][] durationsFromDates = new double[dates.length][datesForDuration.length];
+        int index_dates = 0;
+
+        for (AbsoluteDate date: this.dates) {
+            final double[] durationFromDate = new double[datesForDuration.length];
+            int index_datesForDuration = 0;
+            for (AbsoluteDate dateForDuration: datesForDuration) {
+                durationFromDate[index_datesForDuration] = date.durationFrom(dateForDuration);
+                index_datesForDuration += 1;
+            }
+            durationsFromDates[index_dates] = durationFromDate;
+            index_dates += 1;
+
+        }
+        return (double[][]) durationsFromDates;
+    }
+
+    /** Get array with durations between instances dates and corresponding given dates
+     * If instance dates = [date1, date2, ..., daten] and argument
+     * datesForDuration = [d1, d2, ..., dn] then this function will return
+     * [date1 durationFrom d1, date2 durationFrom d2, ..., daten durationFrom dn]. If
+     * duration from from all arguments dates wants to be compute on each date see
+     * {@link #multipleDurationFrom(AbsoluteDate[])}.
+     * @param datesForDuration dates for which we want to compute the duration form instances dates.
+     * Warning must have same length as instance dates.
+     * @return a array of double representing durations between instance dates and corresponding
+     * argument dates
+     */
+    public double[] durationFrom(final AbsoluteDate[] datesForDuration) {
+
+        // Check same dimensions
+        if (dates.length != datesForDuration.length) {
+            throw new OrekitException(LocalizedCoreFormats.DIMENSIONS_MISMATCH,
+                                      dates.length, datesForDuration.length);
+        }
+
+        final double[] durationsFromDates = new double[dates.length];
+        int index_dates = 0;
+
+        for (AbsoluteDate date: this.dates) {
+            durationsFromDates[index_dates] = date.durationFrom(datesForDuration[index_dates]);
+            index_dates += 1;
+
+        }
+        return durationsFromDates;
+    }
+
+}

src/test/java/org/orekit/rugged/utils/AbsoluteDateForVectorisationTest.java

+/* Copyright 2013-2022 CS GROUP
+ * Licensed to CS GROUP (CS) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * CS licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.orekit.rugged.utils;
+
+
+import org.hipparchus.exception.LocalizedCoreFormats;
+import org.junit.Assert;
+import org.junit.Test;
+import org.orekit.errors.OrekitException;
+import org.orekit.time.AbsoluteDate;
+
+public class AbsoluteDateForVectorisationTest {
+	@Test
+    public void testShiftedBySeveralTimeShiftOneDate() {
+
+		AbsoluteDate date1 = new AbsoluteDate();
+        AbsoluteDate[] dates = new AbsoluteDate[] {date1};
+        double[] dts = new double[] {10.0, 20.0, 30.0};
+	    AbsoluteDateArrayHandling datesForVect = new AbsoluteDateArrayHandling(dates);
+	    AbsoluteDate[][] datesShifted = datesForVect.multipleShiftedBy(dts);
+	    Assert.assertEquals(datesShifted[0][0].durationFrom(date1.shiftedBy(10)), 0.0, 1e-5);
+	    Assert.assertEquals(datesShifted[0][1].durationFrom(date1.shiftedBy(20)), 0.0, 1e-5);
+
+    }
+
+	@Test
+    public void testShiftedByCorrespondingTimeShift() {
+
+		AbsoluteDate date1 = new AbsoluteDate();
+		AbsoluteDate date2 = date1.shiftedBy(10000);
+		AbsoluteDate date3 = date1.shiftedBy(20000);
+        AbsoluteDate[] dates = new AbsoluteDate[] {date1, date2, date3};
+        double[] dts = new double[] {10.0, 20.0, 30.0};
+	    AbsoluteDateArrayHandling datesForVect = new AbsoluteDateArrayHandling(dates);
+	    AbsoluteDate[] datesShifted = datesForVect.shiftedBy(dts);
+	    Assert.assertEquals(datesShifted[0].durationFrom(date1.shiftedBy(10)), 0.0, 1e-5);
+	    Assert.assertEquals(datesShifted[1].durationFrom(date1.shiftedBy(10020)), 0.0, 1e-5);
+	    Assert.assertEquals(datesShifted[2].durationFrom(date1.shiftedBy(20030)), 0.0, 1e-5);
+
+    }
+
+	@Test
+    public void testShiftedBySeveralTimeShiftSeveralDates() {
+
+		AbsoluteDate date1 = new AbsoluteDate();
+		AbsoluteDate date2 = date1.shiftedBy(10000);
+        AbsoluteDate[] dates = new AbsoluteDate[] {date1, date2};
+        double[] dts = new double[] {10.0, 20.0, 30.0};
+	    AbsoluteDateArrayHandling datesForVect = new AbsoluteDateArrayHandling(dates);
+	    AbsoluteDate[][] datesShifted = datesForVect.multipleShiftedBy(dts);
+	    Assert.assertEquals(datesShifted[0][0].durationFrom(date1.shiftedBy(10)), 0.0, 1e-5);
+	    Assert.assertEquals(datesShifted[0][1].durationFrom(date1.shiftedBy(20)), 0.0, 1e-5);
+	    Assert.assertEquals(datesShifted[1][1].durationFrom(date2.shiftedBy(20)), 0.0, 1e-5);
+	    Assert.assertEquals(datesShifted[1][2].durationFrom(date2.shiftedBy(30)), 0.0, 1e-5);
+
+    }
+
+	@Test
+    public void testDurationFromSeveralDates() {
+
+		AbsoluteDate date1 = new AbsoluteDate();
+		AbsoluteDate date2 = date1.shiftedBy(10000);
+		AbsoluteDate date3 = date1.shiftedBy(20000);
+		AbsoluteDate date4 = date1.shiftedBy(100000);
+        AbsoluteDate[] dates = new AbsoluteDate[] {date1, date2, date3};
+        AbsoluteDate[] datesComputeDuration = new AbsoluteDate[] {date4, date1};
+	    AbsoluteDateArrayHandling datesForVect = new AbsoluteDateArrayHandling(dates);
+	    double[][] datesDurations = datesForVect.multipleDurationFrom(datesComputeDuration);
+	    Assert.assertEquals(datesDurations[0][0], date1.durationFrom(date4), 1e-5);
+	    Assert.assertEquals(datesDurations[0][1], date1.durationFrom(date1), 1e-5);
+	    Assert.assertEquals(datesDurations[1][0], date2.durationFrom(date4), 1e-5);
+	    Assert.assertEquals(datesDurations[1][1], date2.durationFrom(date1), 1e-5);
+	    Assert.assertEquals(datesDurations[2][0], date3.durationFrom(date4), 1e-5);
+	    Assert.assertEquals(datesDurations[2][1], date3.durationFrom(date1), 1e-5);
+
+    }
+
+	@Test
+    public void testDurationFromCorrespondingDates() {
+
+		AbsoluteDate date1 = new AbsoluteDate();
+		AbsoluteDate date2 = date1.shiftedBy(10000);
+		AbsoluteDate date3 = date1.shiftedBy(20000);
+		AbsoluteDate date4 = date1.shiftedBy(100000);
+        AbsoluteDate[] dates = new AbsoluteDate[] {date1, date2, date3};
+        AbsoluteDate[] datesComputeDuration = new AbsoluteDate[] {date4, date1, date2};
+	    AbsoluteDateArrayHandling datesForVect = new AbsoluteDateArrayHandling(dates);
+	    double[] datesDurations = datesForVect.durationFrom(datesComputeDuration);
+	    Assert.assertEquals(datesDurations[0], date1.durationFrom(date4), 1e-5);
+	    Assert.assertEquals(datesDurations[1], date2.durationFrom(date1), 1e-5);
+	    Assert.assertEquals(datesDurations[2], date3.durationFrom(date2), 1e-5);
+
+    }
+
+	@Test
+    public void testExceptionDimensions() {
+
+		AbsoluteDate date1 = new AbsoluteDate();
+		AbsoluteDate date2 = date1.shiftedBy(10000);
+		AbsoluteDate date3 = date1.shiftedBy(20000);
+		AbsoluteDate date4 = date1.shiftedBy(100000);
+        AbsoluteDate[] dates = new AbsoluteDate[] {date1, date2, date3};
+        AbsoluteDate[] datesComputeDuration = new AbsoluteDate[] {date4, date1};
+	    AbsoluteDateArrayHandling datesForVect = new AbsoluteDateArrayHandling(dates);
+	    try {
+	    	datesForVect.durationFrom(datesComputeDuration);
+	    	Assert.fail("an exception should have been thrown");
+        } catch (OrekitException oe) {
+        	Assert.assertEquals(LocalizedCoreFormats.DIMENSIONS_MISMATCH, oe.getSpecifier());
+        }
+    }
+
+}