diff --git a/src/main/java/org/orekit/propagation/FieldSpacecraftState.java b/src/main/java/org/orekit/propagation/FieldSpacecraftState.java
index 11d8307f9..c58bd74e8 100644
--- a/src/main/java/org/orekit/propagation/FieldSpacecraftState.java
+++ b/src/main/java/org/orekit/propagation/FieldSpacecraftState.java
@@ -699,10 +699,10 @@ public class FieldSpacecraftState <T extends CalculusFieldElement<T>>
     public FieldSpacecraftState<T> shiftedBy(final double dt) {
         if (absPva == null) {
             return new FieldSpacecraftState<>(orbit.shiftedBy(dt), attitude.shiftedBy(dt),
-                    mass, additional, additionalDot);
+                                              mass, shiftAdditional(dt), additionalDot);
         } else {
             return new FieldSpacecraftState<>(absPva.shiftedBy(dt), attitude.shiftedBy(dt),
-                    mass, additional, additionalDot);
+                                              mass, shiftAdditional(dt), additionalDot);
         }
     }
 
@@ -740,13 +740,63 @@ public class FieldSpacecraftState <T extends CalculusFieldElement<T>>
     public FieldSpacecraftState<T> shiftedBy(final T dt) {
         if (absPva == null) {
             return new FieldSpacecraftState<>(orbit.shiftedBy(dt), attitude.shiftedBy(dt),
-                    mass, additional, additionalDot);
+                                              mass, shiftAdditional(dt), additionalDot);
         } else {
             return new FieldSpacecraftState<>(absPva.shiftedBy(dt), attitude.shiftedBy(dt),
-                    mass, additional, additionalDot);
+                                              mass, shiftAdditional(dt), additionalDot);
         }
     }
 
+    /** Shift additional states.
+     * @param dt time shift in seconds
+     * @return shifted additional states
+     * @since 11.1.1
+     */
+    private FieldArrayDictionary<T> shiftAdditional(final double dt) {
+
+        // fast handling when there are no derivatives at all
+        if (additionalDot.size() == 0) {
+            return additional;
+        }
+
+        // there are derivatives, we need to take them into account in the additional state
+        final FieldArrayDictionary<T> shifted = new FieldArrayDictionary<T>(additional);
+        for (final FieldArrayDictionary<T>.Entry dotEntry : additionalDot.getData()) {
+            final FieldArrayDictionary<T>.Entry entry = shifted.getEntry(dotEntry.getKey());
+            if (entry != null) {
+                entry.scaledIncrement(dt, dotEntry);
+            }
+        }
+
+        return shifted;
+
+    }
+
+    /** Shift additional states.
+     * @param dt time shift in seconds
+     * @return shifted additional states
+     * @since 11.1.1
+     */
+    private FieldArrayDictionary<T> shiftAdditional(final T dt) {
+
+        // fast handling when there are no derivatives at all
+        if (additionalDot.size() == 0) {
+            return additional;
+        }
+
+        // there are derivatives, we need to take them into account in the additional state
+        final FieldArrayDictionary<T> shifted = new FieldArrayDictionary<T>(additional);
+        for (final FieldArrayDictionary<T>.Entry dotEntry : additionalDot.getData()) {
+            final FieldArrayDictionary<T>.Entry entry = shifted.getEntry(dotEntry.getKey());
+            if (entry != null) {
+                entry.scaledIncrement(dt, dotEntry);
+            }
+        }
+
+        return shifted;
+
+    }
+
     /** {@inheritDoc}
      * <p>
      * The additional states that are interpolated are the ones already present
diff --git a/src/main/java/org/orekit/propagation/SpacecraftState.java b/src/main/java/org/orekit/propagation/SpacecraftState.java
index 293c18594..8ab8c77b6 100644
--- a/src/main/java/org/orekit/propagation/SpacecraftState.java
+++ b/src/main/java/org/orekit/propagation/SpacecraftState.java
@@ -627,13 +627,38 @@ public class SpacecraftState
     public SpacecraftState shiftedBy(final double dt) {
         if (absPva == null) {
             return new SpacecraftState(orbit.shiftedBy(dt), attitude.shiftedBy(dt),
-                    mass, additional, additionalDot);
+                                       mass, shiftAdditional(dt), additionalDot);
         } else {
             return new SpacecraftState(absPva.shiftedBy(dt), attitude.shiftedBy(dt),
-                    mass, additional, additionalDot);
+                                       mass, shiftAdditional(dt), additionalDot);
         }
     }
 
+    /** Shift additional states.
+     * @param dt time shift in seconds
+     * @return shifted additional states
+     * @since 11.1.1
+     */
+    private DoubleArrayDictionary shiftAdditional(final double dt) {
+
+        // fast handling when there are no derivatives at all
+        if (additionalDot.size() == 0) {
+            return additional;
+        }
+
+        // there are derivatives, we need to take them into account in the additional state
+        final DoubleArrayDictionary shifted = new DoubleArrayDictionary(additional);
+        for (final DoubleArrayDictionary.Entry dotEntry : additionalDot.getData()) {
+            final DoubleArrayDictionary.Entry entry = shifted.getEntry(dotEntry.getKey());
+            if (entry != null) {
+                entry.scaledIncrement(dt, dotEntry);
+            }
+        }
+
+        return shifted;
+
+    }
+
     /** {@inheritDoc}
      * <p>
      * The additional states that are interpolated are the ones already present
diff --git a/src/main/java/org/orekit/utils/DoubleArrayDictionary.java b/src/main/java/org/orekit/utils/DoubleArrayDictionary.java
index 98685b751..1b02af0e5 100644
--- a/src/main/java/org/orekit/utils/DoubleArrayDictionary.java
+++ b/src/main/java/org/orekit/utils/DoubleArrayDictionary.java
@@ -275,6 +275,23 @@ public class DoubleArrayDictionary implements Serializable {
             }
         }
 
+        /** Increment the value with another scaled entry.
+         * <p>
+         * Each component {@code value[i]} will be replaced by {@code value[i] + factor * raw.value[i]}.
+         * </p>
+         * <p>
+         * For the sake of performance, no checks are done on arguments.
+         * </p>
+         * @param factor multiplicative factor for increment
+         * @param raw raw increment to be multiplied by {@code factor} and then added
+         * @since 11.1.1
+         */
+        public void scaledIncrement(final double factor, final Entry raw) {
+            for (int i = 0; i < raw.value.length; ++i) {
+                value[i] += factor * raw.value[i];
+            }
+        }
+
         /** Reset the value to zero.
          */
         public void zero() {
diff --git a/src/main/java/org/orekit/utils/FieldArrayDictionary.java b/src/main/java/org/orekit/utils/FieldArrayDictionary.java
index f85d3e421..393c0dd88 100644
--- a/src/main/java/org/orekit/utils/FieldArrayDictionary.java
+++ b/src/main/java/org/orekit/utils/FieldArrayDictionary.java
@@ -317,6 +317,40 @@ public class FieldArrayDictionary<T extends CalculusFieldElement<T>> {
             }
         }
 
+        /** Increment the value with another scaled entry.
+         * <p>
+         * Each component {@code value[i]} will be replaced by {@code value[i] + factor * raw.value[i]}.
+         * </p>
+         * <p>
+         * For the sake of performance, no checks are done on arguments.
+         * </p>
+         * @param factor multiplicative factor for increment
+         * @param raw raw increment to be multiplied by {@code factor} and then added
+         * @since 11.1.1
+         */
+        public void scaledIncrement(final T factor, final Entry raw) {
+            for (int i = 0; i < raw.value.length; ++i) {
+                value[i] = value[i].add(raw.value[i].multiply(factor));
+            }
+        }
+
+        /** Increment the value with another scaled entry.
+         * <p>
+         * Each component {@code value[i]} will be replaced by {@code value[i] + factor * raw.value[i]}.
+         * </p>
+         * <p>
+         * For the sake of performance, no checks are done on arguments.
+         * </p>
+         * @param factor multiplicative factor for increment
+         * @param raw raw increment to be multiplied by {@code factor} and then added
+         * @since 11.1.1
+         */
+        public void scaledIncrement(final double factor, final Entry raw) {
+            for (int i = 0; i < raw.value.length; ++i) {
+                value[i] = value[i].add(raw.value[i].multiply(factor));
+            }
+        }
+
         /** Reset the value to zero.
          */
         public void zero() {
diff --git a/src/test/java/org/orekit/estimation/leastsquares/BatchLSEstimatorTest.java b/src/test/java/org/orekit/estimation/leastsquares/BatchLSEstimatorTest.java
index 70bd1e514..e81ded56d 100644
--- a/src/test/java/org/orekit/estimation/leastsquares/BatchLSEstimatorTest.java
+++ b/src/test/java/org/orekit/estimation/leastsquares/BatchLSEstimatorTest.java
@@ -229,10 +229,10 @@ public class BatchLSEstimatorTest {
         aDriver.setReferenceDate(AbsoluteDate.GALILEO_EPOCH);
 
         EstimationTestUtils.checkFit(context, estimator, 2, 3,
-                                     0.0, 1.1e-6,
+                                     0.0, 1.2e-6,
                                      0.0, 2.8e-6,
-                                     0.0, 4.0e-7,
-                                     0.0, 2.2e-10);
+                                     0.0, 5.0e-7,
+                                     0.0, 2.3e-10);
 
         // after the call to estimate, the parameters lacking a user-specified reference date
         // got a default one
@@ -491,7 +491,7 @@ public class BatchLSEstimatorTest {
         Assert.assertEquals(0.0,
                             Vector3D.distance(closeOrbit.getPVCoordinates().getPosition(),
                                               determined.getPVCoordinates().getPosition()),
-                            2.8e-6);
+                            6.2e-6);
         Assert.assertEquals(0.0,
                             Vector3D.distance(closeOrbit.getPVCoordinates().getVelocity(),
                                               determined.getPVCoordinates().getVelocity()),
diff --git a/src/test/java/org/orekit/estimation/sequential/KalmanNumericalOrbitDeterminationTest.java b/src/test/java/org/orekit/estimation/sequential/KalmanNumericalOrbitDeterminationTest.java
index 0bb05f43b..d804bb3f1 100644
--- a/src/test/java/org/orekit/estimation/sequential/KalmanNumericalOrbitDeterminationTest.java
+++ b/src/test/java/org/orekit/estimation/sequential/KalmanNumericalOrbitDeterminationTest.java
@@ -575,7 +575,7 @@ public class KalmanNumericalOrbitDeterminationTest extends AbstractOrbitDetermin
         final double dV = Vector3D.distance(refVel, estimatedVel);
         
         // FIXME: debug - Comparison with batch LS is bad
-        final double debugDistanceAccuracy = 234.73;
+        final double debugDistanceAccuracy = 234.82;
         final double debugVelocityAccuracy = 0.086;
         Assert.assertEquals(0.0, Vector3D.distance(refPos, estimatedPos), debugDistanceAccuracy);
         Assert.assertEquals(0.0, Vector3D.distance(refVel, estimatedVel), debugVelocityAccuracy);
diff --git a/src/test/java/org/orekit/propagation/FieldSpacecraftStateTest.java b/src/test/java/org/orekit/propagation/FieldSpacecraftStateTest.java
index a1728ae9b..2dbdb3a37 100644
--- a/src/test/java/org/orekit/propagation/FieldSpacecraftStateTest.java
+++ b/src/test/java/org/orekit/propagation/FieldSpacecraftStateTest.java
@@ -175,6 +175,16 @@ public class FieldSpacecraftStateTest {
         doTestIssue775(Decimal64Field.getInstance());
     }
 
+    @Test
+    public void testShiftAdditionalDerivativesDouble() {
+        doTestShiftAdditionalDerivativesDouble(Decimal64Field.getInstance());
+    }
+
+    @Test
+    public void testShiftAdditionalDerivativesField() {
+        doTestShiftAdditionalDerivativesField(Decimal64Field.getInstance());
+    }
+
     private <T extends CalculusFieldElement<T>> void doTestFieldVsReal(final Field<T> field) {
         T zero = field.getZero();
 
@@ -1269,9 +1279,88 @@ public class FieldSpacecraftStateTest {
           Assert.assertEquals(0.0, FieldVector3D.distance(withoutOrbit.getAbsPVA().getPosition(), states.get(10).getAbsPVA().getPosition()).getReal(), 1.0e-10);
     }
 
-    
-    
-    
+    private <T extends CalculusFieldElement<T>> void doTestShiftAdditionalDerivativesDouble(final Field<T> field) {
+
+        T zero = field.getZero();
+
+        // Build orbit
+        FieldAbsoluteDate<T> date0 = new FieldAbsoluteDate<>(field, 2000, 1, 1, TimeScalesFactory.getUTC());
+        FieldOrbit<T> orbit = new FieldKeplerianOrbit<>(zero.add(7.1E6), zero, zero, zero, zero, zero,
+                                         PositionAngle.TRUE, FramesFactory.getGCRF(), date0,
+                                         zero.add(Constants.WGS84_EARTH_MU));
+
+        // Build propagator
+        FieldKeplerianPropagator<T> propagator = new FieldKeplerianPropagator<>(orbit);
+
+        final String valueAndDerivative = "value-and-derivative";
+        final String valueOnly          = "value-only";
+        final String derivativeOnly     = "derivative-only";
+        final FieldSpacecraftState<T> s0 = propagator.getInitialState().
+                                           addAdditionalState(valueAndDerivative,           convert(field, new double[] { 1.0,  2.0 })).
+                                           addAdditionalStateDerivative(valueAndDerivative, convert(field, new double[] { 3.0,  2.0 })).
+                                           addAdditionalState(valueOnly,                    convert(field, new double[] { 5.0,  4.0 })).
+                                           addAdditionalStateDerivative(derivativeOnly,     convert(field, new double[] { 1.0, -1.0 }));
+        Assert.assertEquals( 1.0, s0.getAdditionalState(valueAndDerivative)[0].getReal(),           1.0e-15);
+        Assert.assertEquals( 2.0, s0.getAdditionalState(valueAndDerivative)[1].getReal(),           1.0e-15);
+        Assert.assertEquals( 3.0, s0.getAdditionalStateDerivative(valueAndDerivative)[0].getReal(), 1.0e-15);
+        Assert.assertEquals( 2.0, s0.getAdditionalStateDerivative(valueAndDerivative)[1].getReal(), 1.0e-15);
+        Assert.assertEquals( 5.0, s0.getAdditionalState(valueOnly)[0].getReal(),                    1.0e-15);
+        Assert.assertEquals( 4.0, s0.getAdditionalState(valueOnly)[1].getReal(),                    1.0e-15);
+        Assert.assertEquals( 1.0, s0.getAdditionalStateDerivative(derivativeOnly)[0].getReal(),     1.0e-15);
+        Assert.assertEquals(-1.0, s0.getAdditionalStateDerivative(derivativeOnly)[1].getReal(),     1.0e-15);
+        final FieldSpacecraftState<T> s1 = s0.shiftedBy(-2.0);
+        Assert.assertEquals(-5.0, s1.getAdditionalState(valueAndDerivative)[0].getReal(),           1.0e-15);
+        Assert.assertEquals(-2.0, s1.getAdditionalState(valueAndDerivative)[1].getReal(),           1.0e-15);
+        Assert.assertEquals( 3.0, s1.getAdditionalStateDerivative(valueAndDerivative)[0].getReal(), 1.0e-15);
+        Assert.assertEquals( 2.0, s1.getAdditionalStateDerivative(valueAndDerivative)[1].getReal(), 1.0e-15);
+        Assert.assertEquals( 5.0, s1.getAdditionalState(valueOnly)[0].getReal(),                    1.0e-15);
+        Assert.assertEquals( 4.0, s1.getAdditionalState(valueOnly)[1].getReal(),                    1.0e-15);
+        Assert.assertEquals( 1.0, s1.getAdditionalStateDerivative(derivativeOnly)[0].getReal(),     1.0e-15);
+        Assert.assertEquals(-1.0, s1.getAdditionalStateDerivative(derivativeOnly)[1].getReal(),     1.0e-15);
+
+    }
+
+    private <T extends CalculusFieldElement<T>> void doTestShiftAdditionalDerivativesField(final Field<T> field) {
+
+        T zero = field.getZero();
+
+        // Build orbit
+        FieldAbsoluteDate<T> date0 = new FieldAbsoluteDate<>(field, 2000, 1, 1, TimeScalesFactory.getUTC());
+        FieldOrbit<T> orbit = new FieldKeplerianOrbit<>(zero.add(7.1E6), zero, zero, zero, zero, zero,
+                                         PositionAngle.TRUE, FramesFactory.getGCRF(), date0,
+                                         zero.add(Constants.WGS84_EARTH_MU));
+
+        // Build propagator
+        FieldKeplerianPropagator<T> propagator = new FieldKeplerianPropagator<>(orbit);
+
+        final String valueAndDerivative = "value-and-derivative";
+        final String valueOnly          = "value-only";
+        final String derivativeOnly     = "derivative-only";
+        final FieldSpacecraftState<T> s0 = propagator.getInitialState().
+                                           addAdditionalState(valueAndDerivative,           convert(field, new double[] { 1.0,  2.0 })).
+                                           addAdditionalStateDerivative(valueAndDerivative, convert(field, new double[] { 3.0,  2.0 })).
+                                           addAdditionalState(valueOnly,                    convert(field, new double[] { 5.0,  4.0 })).
+                                           addAdditionalStateDerivative(derivativeOnly,     convert(field, new double[] { 1.0, -1.0 }));
+        Assert.assertEquals( 1.0, s0.getAdditionalState(valueAndDerivative)[0].getReal(),           1.0e-15);
+        Assert.assertEquals( 2.0, s0.getAdditionalState(valueAndDerivative)[1].getReal(),           1.0e-15);
+        Assert.assertEquals( 3.0, s0.getAdditionalStateDerivative(valueAndDerivative)[0].getReal(), 1.0e-15);
+        Assert.assertEquals( 2.0, s0.getAdditionalStateDerivative(valueAndDerivative)[1].getReal(), 1.0e-15);
+        Assert.assertEquals( 5.0, s0.getAdditionalState(valueOnly)[0].getReal(),                    1.0e-15);
+        Assert.assertEquals( 4.0, s0.getAdditionalState(valueOnly)[1].getReal(),                    1.0e-15);
+        Assert.assertEquals( 1.0, s0.getAdditionalStateDerivative(derivativeOnly)[0].getReal(),     1.0e-15);
+        Assert.assertEquals(-1.0, s0.getAdditionalStateDerivative(derivativeOnly)[1].getReal(),     1.0e-15);
+        final FieldSpacecraftState<T> s1 = s0.shiftedBy(field.getZero().newInstance(-2.0));
+        Assert.assertEquals(-5.0, s1.getAdditionalState(valueAndDerivative)[0].getReal(),           1.0e-15);
+        Assert.assertEquals(-2.0, s1.getAdditionalState(valueAndDerivative)[1].getReal(),           1.0e-15);
+        Assert.assertEquals( 3.0, s1.getAdditionalStateDerivative(valueAndDerivative)[0].getReal(), 1.0e-15);
+        Assert.assertEquals( 2.0, s1.getAdditionalStateDerivative(valueAndDerivative)[1].getReal(), 1.0e-15);
+        Assert.assertEquals( 5.0, s1.getAdditionalState(valueOnly)[0].getReal(),                    1.0e-15);
+        Assert.assertEquals( 4.0, s1.getAdditionalState(valueOnly)[1].getReal(),                    1.0e-15);
+        Assert.assertEquals( 1.0, s1.getAdditionalStateDerivative(derivativeOnly)[0].getReal(),     1.0e-15);
+        Assert.assertEquals(-1.0, s1.getAdditionalStateDerivative(derivativeOnly)[1].getReal(),     1.0e-15);
+
+    }
+
     @Before
     public void setUp(){
         try {
@@ -1300,6 +1389,14 @@ public class FieldSpacecraftStateTest {
         }
     }
 
+    private <T extends CalculusFieldElement<T>> T[] convert(final Field<T> field, final double[] a) {
+        final T[] converted = MathArrays.buildArray(field, a.length);
+        for (int i = 0; i < a.length; ++i) {
+            converted[i] = field.getZero().newInstance(a[i]);
+        }
+        return converted;
+    }
+
     private AbsoluteDate rDate;
     private double mu;
     private Orbit rOrbit;
diff --git a/src/test/java/org/orekit/propagation/SpacecraftStateTest.java b/src/test/java/org/orekit/propagation/SpacecraftStateTest.java
index 281b282bd..e6117c7dd 100644
--- a/src/test/java/org/orekit/propagation/SpacecraftStateTest.java
+++ b/src/test/java/org/orekit/propagation/SpacecraftStateTest.java
@@ -803,6 +803,37 @@ public class SpacecraftStateTest {
 
     }
 
+    @Test
+    public void testShiftAdditionalDerivatives() {
+
+        final String valueAndDerivative = "value-and-derivative";
+        final String valueOnly          = "value-only";
+        final String derivativeOnly     = "derivative-only";
+        final SpacecraftState s0 = propagator.getInitialState().
+                                   addAdditionalState(valueAndDerivative,           new double[] { 1.0,  2.0 }).
+                                   addAdditionalStateDerivative(valueAndDerivative, new double[] { 3.0,  2.0 }).
+                                   addAdditionalState(valueOnly,                    new double[] { 5.0,  4.0 }).
+                                   addAdditionalStateDerivative(derivativeOnly,     new double[] { 1.0, -1.0 });
+        Assert.assertEquals( 1.0, s0.getAdditionalState(valueAndDerivative)[0],           1.0e-15);
+        Assert.assertEquals( 2.0, s0.getAdditionalState(valueAndDerivative)[1],           1.0e-15);
+        Assert.assertEquals( 3.0, s0.getAdditionalStateDerivative(valueAndDerivative)[0], 1.0e-15);
+        Assert.assertEquals( 2.0, s0.getAdditionalStateDerivative(valueAndDerivative)[1], 1.0e-15);
+        Assert.assertEquals( 5.0, s0.getAdditionalState(valueOnly)[0],                    1.0e-15);
+        Assert.assertEquals( 4.0, s0.getAdditionalState(valueOnly)[1],                    1.0e-15);
+        Assert.assertEquals( 1.0, s0.getAdditionalStateDerivative(derivativeOnly)[0],     1.0e-15);
+        Assert.assertEquals(-1.0, s0.getAdditionalStateDerivative(derivativeOnly)[1],     1.0e-15);
+        final SpacecraftState s1 = s0.shiftedBy(-2.0);
+        Assert.assertEquals(-5.0, s1.getAdditionalState(valueAndDerivative)[0],           1.0e-15);
+        Assert.assertEquals(-2.0, s1.getAdditionalState(valueAndDerivative)[1],           1.0e-15);
+        Assert.assertEquals( 3.0, s1.getAdditionalStateDerivative(valueAndDerivative)[0], 1.0e-15);
+        Assert.assertEquals( 2.0, s1.getAdditionalStateDerivative(valueAndDerivative)[1], 1.0e-15);
+        Assert.assertEquals( 5.0, s1.getAdditionalState(valueOnly)[0],                    1.0e-15);
+        Assert.assertEquals( 4.0, s1.getAdditionalState(valueOnly)[1],                    1.0e-15);
+        Assert.assertEquals( 1.0, s1.getAdditionalStateDerivative(derivativeOnly)[0],     1.0e-15);
+        Assert.assertEquals(-1.0, s1.getAdditionalStateDerivative(derivativeOnly)[1],     1.0e-15);
+
+    }
+
     @Before
     public void setUp() {
         try {
diff --git a/src/test/java/org/orekit/utils/DoubleArrayDictionaryTest.java b/src/test/java/org/orekit/utils/DoubleArrayDictionaryTest.java
index 1d7679a1f..0e5971387 100644
--- a/src/test/java/org/orekit/utils/DoubleArrayDictionaryTest.java
+++ b/src/test/java/org/orekit/utils/DoubleArrayDictionaryTest.java
@@ -99,6 +99,16 @@ public class DoubleArrayDictionaryTest {
         Assert.assertArrayEquals(new double[] { 3.0, 6.0, 11.0 }, dictionary.get("a"), 1.0e-15);
     }
 
+    @Test
+    public void testScaledIncrement() {
+        DoubleArrayDictionary dictionary = new DoubleArrayDictionary();
+        dictionary.put("a",       new double[] { 1.0, 2.0, 3.0 });
+        DoubleArrayDictionary other = new DoubleArrayDictionary();
+        other.put("aDot",       new double[] { 3.0, 2.0, 1.0 });
+        dictionary.getEntry("a").scaledIncrement(2.0, other.getEntry("aDot"));
+        Assert.assertArrayEquals(new double[] { 7.0, 6.0, 5.0 }, dictionary.get("a"), 1.0e-15);
+    }
+
     @Test
     public void testZero() {
         DoubleArrayDictionary dictionary = new DoubleArrayDictionary();
diff --git a/src/test/java/org/orekit/utils/FieldArrayDictionaryTest.java b/src/test/java/org/orekit/utils/FieldArrayDictionaryTest.java
index 2b4a99ca3..8c55d1e70 100644
--- a/src/test/java/org/orekit/utils/FieldArrayDictionaryTest.java
+++ b/src/test/java/org/orekit/utils/FieldArrayDictionaryTest.java
@@ -65,6 +65,16 @@ public class FieldArrayDictionaryTest {
         doTestIncrementDouble(Decimal64Field.getInstance());
     }
 
+    @Test
+    public void testScaledIncrementField() {
+        doTestScaledIncrementField(Decimal64Field.getInstance());
+    }
+
+    @Test
+    public void testScaledIncrementDouble() {
+        doTestScaledIncrementDouble(Decimal64Field.getInstance());
+    }
+
     @Test
     public void testZero() {
         doTestZero(Decimal64Field.getInstance());
@@ -179,6 +189,24 @@ public class FieldArrayDictionaryTest {
         checkArray(new double[] { 3.0, 6.0, 11.0 }, dictionary.get("a"), 1.0e-15);
     }
 
+    private <T extends CalculusFieldElement<T>> void doTestScaledIncrementField(Field<T> field) {
+        FieldArrayDictionary<T> dictionary = new FieldArrayDictionary<>(field);
+        dictionary.put("a",       convert(field, new double[] { 1.0, 2.0, 3.0 }));
+        FieldArrayDictionary<T> other = new FieldArrayDictionary<>(field);
+        other.put("aDot",       convert(field, new double[] { 3.0, 2.0, 1.0 }));
+        dictionary.getEntry("a").scaledIncrement(field.getZero().newInstance(2.0), other.getEntry("aDot"));
+        checkArray(new double[] { 7.0, 6.0, 5.0 }, dictionary.get("a"), 1.0e-15);
+    }
+
+    private <T extends CalculusFieldElement<T>> void doTestScaledIncrementDouble(Field<T> field) {
+        FieldArrayDictionary<T> dictionary = new FieldArrayDictionary<>(field);
+        dictionary.put("a",       convert(field, new double[] { 1.0, 2.0, 3.0 }));
+        FieldArrayDictionary<T> other = new FieldArrayDictionary<>(field);
+        other.put("aDot",       convert(field, new double[] { 3.0, 2.0, 1.0 }));
+        dictionary.getEntry("a").scaledIncrement(2.0, other.getEntry("aDot"));
+        checkArray(new double[] { 7.0, 6.0, 5.0 }, dictionary.get("a"), 1.0e-15);
+    }
+
     private <T extends CalculusFieldElement<T>> void doTestZero(Field<T> field) {
         FieldArrayDictionary<T> dictionary = new FieldArrayDictionary<>(field);
         dictionary.put("a",       new double[] { 1.0, 2.0, 3.0 });
