MATH-1630: Runtime switch between JDK and CM implementations of the methods defined in "java.lang.Math".

Default is to use the CM implementations in order to retain previous behaviour.
When using the JDK implementations, some unit tests fail (on Java 8).

Class "AccurateMath" was moved to "o.a.c.math4.core" package.
[Unit tests for that class were not moved because they depend on "legacy" classes.]
diff --git a/commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMath.java b/commons-math-core/src/main/java/org/apache/commons/math4/core/jdkmath/AccurateMath.java
similarity index 99%
rename from commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMath.java
rename to commons-math-core/src/main/java/org/apache/commons/math4/core/jdkmath/AccurateMath.java
index 88cd91a..8687030 100644
--- a/commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMath.java
+++ b/commons-math-core/src/main/java/org/apache/commons/math4/core/jdkmath/AccurateMath.java
@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.apache.commons.math4.legacy.core.jdkmath;
+package org.apache.commons.math4.core.jdkmath;
 
 import java.io.PrintStream;
 
diff --git a/commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMathCalc.java b/commons-math-core/src/main/java/org/apache/commons/math4/core/jdkmath/AccurateMathCalc.java
similarity index 97%
rename from commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMathCalc.java
rename to commons-math-core/src/main/java/org/apache/commons/math4/core/jdkmath/AccurateMathCalc.java
index e9ec154..b4b57aa 100644
--- a/commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMathCalc.java
+++ b/commons-math-core/src/main/java/org/apache/commons/math4/core/jdkmath/AccurateMathCalc.java
@@ -14,11 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.apache.commons.math4.legacy.core.jdkmath;
+package org.apache.commons.math4.core.jdkmath;
 
 import java.io.PrintStream;
 
-import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
 
 /** Class used to compute the classical functions tables.
  * @since 3.0
@@ -647,12 +646,11 @@
      * Check two lengths are equal.
      * @param expectedLen expected length
      * @param actual actual length
-     * @exception DimensionMismatchException if the two lengths are not equal
+     * @throws IllegalStateException if the two lengths are not equal
      */
-    private static void checkLen(int expectedLen, int actual)
-        throws DimensionMismatchException {
+    private static void checkLen(int expectedLen, int actual) {
         if (expectedLen != actual) {
-            throw new DimensionMismatchException(actual, expectedLen);
+            throw new IllegalStateException(actual + " != " + expectedLen);
         }
     }
 }
diff --git a/commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMathLiteralArrays.java b/commons-math-core/src/main/java/org/apache/commons/math4/core/jdkmath/AccurateMathLiteralArrays.java
similarity index 99%
rename from commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMathLiteralArrays.java
rename to commons-math-core/src/main/java/org/apache/commons/math4/core/jdkmath/AccurateMathLiteralArrays.java
index 7d7c1ba..c53a4bc 100644
--- a/commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMathLiteralArrays.java
+++ b/commons-math-core/src/main/java/org/apache/commons/math4/core/jdkmath/AccurateMathLiteralArrays.java
@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-package org.apache.commons.math4.legacy.core.jdkmath;
+package org.apache.commons.math4.core.jdkmath;
 
 /**
  * Utility class for loading tabulated data used by {@link AccurateMath}.
diff --git a/commons-math-core/src/main/java/org/apache/commons/math4/core/jdkmath/JdkMath.java b/commons-math-core/src/main/java/org/apache/commons/math4/core/jdkmath/JdkMath.java
new file mode 100644
index 0000000..37295c8
--- /dev/null
+++ b/commons-math-core/src/main/java/org/apache/commons/math4/core/jdkmath/JdkMath.java
@@ -0,0 +1,1108 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF 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.apache.commons.math4.core.jdkmath;
+
+import java.util.function.IntUnaryOperator;
+import java.util.function.IntBinaryOperator;
+import java.util.function.LongUnaryOperator;
+import java.util.function.LongBinaryOperator;
+import java.util.function.DoubleUnaryOperator;
+import java.util.function.DoubleBinaryOperator;
+import java.util.function.DoubleToLongFunction;
+import java.util.function.DoubleToIntFunction;
+import java.util.function.LongToIntFunction;
+import java.util.function.DoubleSupplier;
+
+/**
+ * Wrapper for alternative implementations of {@link Math} functions.
+ *
+ * Based on the value, at class initialization, of the system property
+ * {@code org.apache.commons.math.jdkmath}, this class redirects to a
+ * specific implementation:
+ * <ul>
+ *  <li>{@code CM}: {@link AccurateMath}</li>
+ *  <li>{@code JDK}: {@link Math}</li>
+ * </ul>
+ * When the property is undefined, {@code CM} is the default value.
+ */
+public final class JdkMath {
+    /** Constant. */
+    public static final double PI;
+    /** Constant. */
+    public static final double E;
+    /** Property identifier.. */
+    private static final String PROPERTY_KEY = "org.apache.commons.math.jdkmath";
+    /** abs(x). */
+    private static final IntUnaryOperator ABS_INT;
+    /** abs(x). */
+    private static final LongUnaryOperator ABS_LONG;
+    /** abs(x). */
+    private static final FloatUnaryOperator ABS_FLOAT;
+    /** abs(x). */
+    private static final DoubleUnaryOperator ABS_DOUBLE;
+    /** acos(x). */
+    private static final DoubleUnaryOperator ACOS;
+    /** acosh(x). */
+    private static final DoubleUnaryOperator ACOSH;
+    /** addExact(x, y). */
+    private static final IntBinaryOperator ADDEXACT_INT;
+    /** addExact(x, y). */
+    private static final LongBinaryOperator ADDEXACT_LONG;
+    /** asin(x). */
+    private static final DoubleUnaryOperator ASIN;
+    /** asinh(x). */
+    private static final DoubleUnaryOperator ASINH;
+    /** atan(x). */
+    private static final DoubleUnaryOperator ATAN;
+    /** atan2(x, y). */
+    private static final DoubleBinaryOperator ATAN2;
+    /** atanh(x). */
+    private static final DoubleUnaryOperator ATANH;
+    /** cbrt(x). */
+    private static final DoubleUnaryOperator CBRT;
+    /** ceil(x). */
+    private static final DoubleUnaryOperator CEIL;
+    /** copySign(x, y). */
+    private static final FloatBinaryOperator COPYSIGN_FLOAT;
+    /** copySign(x, y). */
+    private static final DoubleBinaryOperator COPYSIGN_DOUBLE;
+    /** cos(x). */
+    private static final DoubleUnaryOperator COS;
+    /** cosh(x). */
+    private static final DoubleUnaryOperator COSH;
+    /** decrementExact(x). */
+    private static final IntUnaryOperator DECREMENTEXACT_INT;
+    /** decrementExact(x). */
+    private static final LongUnaryOperator DECREMENTEXACT_LONG;
+    /** exp(x). */
+    private static final DoubleUnaryOperator EXP;
+    /** expm1(x). */
+    private static final DoubleUnaryOperator EXPM1;
+    /** floor(x). */
+    private static final DoubleUnaryOperator FLOOR;
+    /** floorDiv(x, y). */
+    private static final IntBinaryOperator FLOORDIV_INT;
+    /** floorDiv(x, y). */
+    private static final LongBinaryOperator FLOORDIV_LONG;
+    /** floorMod(x, y). */
+    private static final IntBinaryOperator FLOORMOD_INT;
+    /** floorMod(x, y). */
+    private static final LongBinaryOperator FLOORMOD_LONG;
+    /** getExponent(x). */
+    private static final FloatToIntFunction GETEXPONENT_FLOAT;
+    /** getExponent(x). */
+    private static final DoubleToIntFunction GETEXPONENT_DOUBLE;
+    /** hypot(x, y). */
+    private static final DoubleBinaryOperator HYPOT;
+    /** IEEEremainder(x, y). */
+    private static final DoubleBinaryOperator IEEEREMAINDER;
+    /** incrementExact(x). */
+    private static final IntUnaryOperator INCREMENTEXACT_INT;
+    /** incrementExact(x). */
+    private static final LongUnaryOperator INCREMENTEXACT_LONG;
+    /** log(x). */
+    private static final DoubleUnaryOperator LOG;
+    /** log10(x). */
+    private static final DoubleUnaryOperator LOG10;
+    /** log1p(x). */
+    private static final DoubleUnaryOperator LOG1P;
+    /** max(x, y). */
+    private static final IntBinaryOperator MAX_INT;
+    /** max(x, y). */
+    private static final LongBinaryOperator MAX_LONG;
+    /** max(x, y). */
+    private static final FloatBinaryOperator MAX_FLOAT;
+    /** max(x, y). */
+    private static final DoubleBinaryOperator MAX_DOUBLE;
+    /** min(x, y). */
+    private static final IntBinaryOperator MIN_INT;
+    /** min(x, y). */
+    private static final LongBinaryOperator MIN_LONG;
+    /** min(x, y). */
+    private static final FloatBinaryOperator MIN_FLOAT;
+    /** min(x, y). */
+    private static final DoubleBinaryOperator MIN_DOUBLE;
+    /** multiplyExact(x, y). */
+    private static final IntBinaryOperator MULTIPLYEXACT_INT;
+    /** multiplyExact(x, y). */
+    private static final LongBinaryOperator MULTIPLYEXACT_LONG;
+    /** negateExact(x). */
+    private static final IntUnaryOperator NEGATEEXACT_INT;
+    /** negateExact(x). */
+    private static final LongUnaryOperator NEGATEEXACT_LONG;
+    /** nextAfter(x, y). */
+    private static final FloatDouble2FloatOperator NEXTAFTER_FLOAT;
+    /** nextAfter(x, y). */
+    private static final DoubleBinaryOperator NEXTAFTER_DOUBLE;
+    /** nextDown(x). */
+    private static final FloatUnaryOperator NEXTDOWN_FLOAT;
+    /** nextDown(x). */
+    private static final DoubleUnaryOperator NEXTDOWN_DOUBLE;
+    /** nextUp(x). */
+    private static final FloatUnaryOperator NEXTUP_FLOAT;
+    /** nextUp(x). */
+    private static final DoubleUnaryOperator NEXTUP_DOUBLE;
+    /** pow(x, y). */
+    private static final DoubleBinaryOperator POW;
+    /** random(). */
+    private static final DoubleSupplier RANDOM;
+    /** rint(x). */
+    private static final DoubleUnaryOperator RINT;
+    /** round(x). */
+    private static final DoubleToLongFunction ROUND_DOUBLE;
+    /** round(x). */
+    private static final FloatToIntFunction ROUND_FLOAT;
+    /** scalb(x, y). */
+    private static final DoubleInt2DoubleOperator SCALB_DOUBLE;
+    /** scalb(x, y). */
+    private static final FloatInt2FloatOperator SCALB_FLOAT;
+    /** signum(x). */
+    private static final FloatUnaryOperator SIGNUM_FLOAT;
+    /** signum(x). */
+    private static final DoubleUnaryOperator SIGNUM_DOUBLE;
+    /** sin(x). */
+    private static final DoubleUnaryOperator SIN;
+    /** sinh(x). */
+    private static final DoubleUnaryOperator SINH;
+    /** sqrt(x). */
+    private static final DoubleUnaryOperator SQRT;
+    /** subtractExact(x, y). */
+    private static final IntBinaryOperator SUBTRACTEXACT_INT;
+    /** subtractExact(x, y). */
+    private static final LongBinaryOperator SUBTRACTEXACT_LONG;
+    /** tan(x). */
+    private static final DoubleUnaryOperator TAN;
+    /** tanh(x). */
+    private static final DoubleUnaryOperator TANH;
+    /** toDegrees(x). */
+    private static final DoubleUnaryOperator TODEGREES;
+    /** toIntExact(x). */
+    private static final LongToIntFunction TOINTEXACT;
+    /** toRadians(x). */
+    private static final DoubleUnaryOperator TORADIANS;
+    /** ulp(x). */
+    private static final DoubleUnaryOperator ULP_DOUBLE;
+    /** ulp(x). */
+    private static final FloatUnaryOperator ULP_FLOAT;
+
+    /** Available implementations of {@link Math} functions. */
+    public enum Impl {
+        /** {@link AccurateMath Commons Math}. */
+        CM,
+        /** {@link Math JDK}. */
+        JDK
+    }
+
+    static {
+        final String prop = System.getProperty(PROPERTY_KEY);
+        final Impl impl = prop != null ?
+            Impl.valueOf(prop) :
+            Impl.CM;
+
+
+        switch (impl) {
+        case CM:
+            PI = AccurateMath.PI;
+            E = AccurateMath.E;
+            ABS_INT = AccurateMath::abs;
+            ABS_LONG = AccurateMath::abs;
+            ABS_FLOAT = AccurateMath::abs;
+            ABS_DOUBLE = AccurateMath::abs;
+            ACOS = AccurateMath::acos;
+            ACOSH = AccurateMath::acosh;
+            ADDEXACT_INT = AccurateMath::addExact;
+            ADDEXACT_LONG = AccurateMath::addExact;
+            ASIN = AccurateMath::asin;
+            ASINH = AccurateMath::asinh;
+            ATAN = AccurateMath::atan;
+            ATAN2 = AccurateMath::atan2;
+            ATANH = AccurateMath::atanh;
+            CBRT = AccurateMath::cbrt;
+            CEIL = AccurateMath::ceil;
+            COPYSIGN_FLOAT = AccurateMath::copySign;
+            COPYSIGN_DOUBLE = AccurateMath::copySign;
+            COS = AccurateMath::cos;
+            COSH = AccurateMath::cosh;
+            DECREMENTEXACT_INT = AccurateMath::decrementExact;
+            DECREMENTEXACT_LONG = AccurateMath::decrementExact;
+            EXP = AccurateMath::exp;
+            EXPM1 = AccurateMath::expm1;
+            FLOOR = AccurateMath::floor;
+            FLOORDIV_INT = AccurateMath::floorDiv;
+            FLOORDIV_LONG = AccurateMath::floorDiv;
+            FLOORMOD_INT = AccurateMath::floorMod;
+            FLOORMOD_LONG = AccurateMath::floorMod;
+            GETEXPONENT_FLOAT = AccurateMath::getExponent;
+            GETEXPONENT_DOUBLE = AccurateMath::getExponent;
+            HYPOT = AccurateMath::hypot;
+            IEEEREMAINDER = AccurateMath::IEEEremainder;
+            INCREMENTEXACT_INT = AccurateMath::incrementExact;
+            INCREMENTEXACT_LONG = AccurateMath::incrementExact;
+            LOG = AccurateMath::log;
+            LOG10 = AccurateMath::log10;
+            LOG1P = AccurateMath::log1p;
+            MAX_INT = AccurateMath::max;
+            MAX_LONG = AccurateMath::max;
+            MAX_FLOAT = AccurateMath::max;
+            MAX_DOUBLE = AccurateMath::max;
+            MIN_INT = AccurateMath::min;
+            MIN_LONG = AccurateMath::min;
+            MIN_FLOAT = AccurateMath::min;
+            MIN_DOUBLE = AccurateMath::min;
+            MULTIPLYEXACT_INT = AccurateMath::multiplyExact;
+            MULTIPLYEXACT_LONG = AccurateMath::multiplyExact;
+            NEGATEEXACT_INT = Math::negateExact; // Not implemented.
+            NEGATEEXACT_LONG = Math::negateExact; // Not implemented.
+            NEXTAFTER_FLOAT = AccurateMath::nextAfter;
+            NEXTAFTER_DOUBLE = AccurateMath::nextAfter;
+            NEXTDOWN_FLOAT = AccurateMath::nextDown;
+            NEXTDOWN_DOUBLE = AccurateMath::nextDown;
+            NEXTUP_FLOAT = AccurateMath::nextUp;
+            NEXTUP_DOUBLE = AccurateMath::nextUp;
+            POW = AccurateMath::pow;
+            RANDOM = AccurateMath::random;
+            RINT = AccurateMath::rint;
+            ROUND_DOUBLE = AccurateMath::round;
+            ROUND_FLOAT = AccurateMath::round;
+            SCALB_DOUBLE = AccurateMath::scalb;
+            SCALB_FLOAT = AccurateMath::scalb;
+            SIGNUM_DOUBLE = AccurateMath::signum;
+            SIGNUM_FLOAT = AccurateMath::signum;
+            SQRT = AccurateMath::sqrt;
+            SIN = AccurateMath::sin;
+            SINH = AccurateMath::sinh;
+            SUBTRACTEXACT_INT = AccurateMath::subtractExact;
+            SUBTRACTEXACT_LONG = AccurateMath::subtractExact;
+            TAN = AccurateMath::tan;
+            TANH = AccurateMath::tanh;
+            TODEGREES = AccurateMath::toDegrees;
+            TOINTEXACT = AccurateMath::toIntExact;
+            TORADIANS = AccurateMath::toRadians;
+            ULP_DOUBLE = AccurateMath::ulp;
+            ULP_FLOAT = AccurateMath::ulp;
+            break;
+
+        case JDK:
+            PI = Math.PI;
+            E = Math.E;
+            ABS_INT = Math::abs;
+            ABS_LONG = Math::abs;
+            ABS_FLOAT = Math::abs;
+            ABS_DOUBLE = Math::abs;
+            ACOS = Math::acos;
+            ACOSH = AccurateMath::acosh; // Not implemented.
+            ADDEXACT_INT = Math::addExact;
+            ADDEXACT_LONG = Math::addExact;
+            ASIN = Math::asin;
+            ASINH = AccurateMath::asinh; // Not implemented.
+            ATAN = Math::atan;
+            ATAN2 = Math::atan2;
+            ATANH = AccurateMath::atanh; // Not implemented.
+            CBRT = Math::cbrt;
+            CEIL = Math::ceil;
+            COPYSIGN_FLOAT = Math::copySign;
+            COPYSIGN_DOUBLE = Math::copySign;
+            COS = Math::cos;
+            COSH = Math::cosh;
+            DECREMENTEXACT_INT = Math::decrementExact;
+            DECREMENTEXACT_LONG = Math::decrementExact;
+            EXP = Math::exp;
+            EXPM1 = Math::expm1;
+            FLOOR = Math::floor;
+            FLOORDIV_INT = Math::floorDiv;
+            FLOORDIV_LONG = Math::floorDiv;
+            FLOORMOD_INT = Math::floorMod;
+            FLOORMOD_LONG = Math::floorMod;
+            GETEXPONENT_FLOAT = Math::getExponent;
+            GETEXPONENT_DOUBLE = Math::getExponent;
+            HYPOT = Math::hypot;
+            IEEEREMAINDER = Math::IEEEremainder;
+            INCREMENTEXACT_INT = Math::incrementExact;
+            INCREMENTEXACT_LONG = Math::incrementExact;
+            LOG = Math::log;
+            LOG10 = Math::log10;
+            LOG1P = Math::log1p;
+            MAX_INT = Math::max;
+            MAX_LONG = Math::max;
+            MAX_FLOAT = Math::max;
+            MAX_DOUBLE = Math::max;
+            MIN_INT = Math::min;
+            MIN_LONG = Math::min;
+            MIN_FLOAT = Math::min;
+            MIN_DOUBLE = Math::min;
+            MULTIPLYEXACT_INT = Math::multiplyExact;
+            MULTIPLYEXACT_LONG = Math::multiplyExact;
+            NEGATEEXACT_INT = Math::negateExact;
+            NEGATEEXACT_LONG = Math::negateExact;
+            NEXTAFTER_FLOAT = Math::nextAfter;
+            NEXTAFTER_DOUBLE = Math::nextAfter;
+            NEXTDOWN_FLOAT = Math::nextDown;
+            NEXTDOWN_DOUBLE = Math::nextDown;
+            NEXTUP_FLOAT = Math::nextUp;
+            NEXTUP_DOUBLE = Math::nextUp;
+            POW = Math::pow;
+            RANDOM = Math::random;
+            RINT = Math::rint;
+            ROUND_DOUBLE = Math::round;
+            ROUND_FLOAT = Math::round;
+            SCALB_DOUBLE = Math::scalb;
+            SCALB_FLOAT = Math::scalb;
+            SIGNUM_DOUBLE = Math::signum;
+            SIGNUM_FLOAT = Math::signum;
+            SIN = Math::sin;
+            SINH = Math::sinh;
+            SQRT = Math::sqrt;
+            SUBTRACTEXACT_INT = Math::subtractExact;
+            SUBTRACTEXACT_LONG = Math::subtractExact;
+            TAN = Math::tan;
+            TANH = Math::tanh;
+            TODEGREES = Math::toDegrees;
+            TOINTEXACT = Math::toIntExact;
+            TORADIANS = Math::toRadians;
+            ULP_DOUBLE = Math::ulp;
+            ULP_FLOAT = Math::ulp;
+            break;
+
+        default:
+            throw new IllegalStateException("Internal error"); // Should never happen.
+        }
+    }
+
+    /** Utility class. */
+    private JdkMath() {}
+
+    /**
+     * @param x Number.
+     * @return abs(x).
+     */
+    public static int abs(int x) {
+        return ABS_INT.applyAsInt(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return abs(x).
+     */
+    public static long abs(long x) {
+        return ABS_LONG.applyAsLong(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return abs(x).
+     */
+    public static float abs(float x) {
+        return ABS_FLOAT.applyAsFloat(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return abs(x).
+     */
+    public static double abs(double x) {
+        return ABS_DOUBLE.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return acos(x).
+     */
+    public static double acos(double x) {
+        return ACOS.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return acosh(x).
+     */
+    public static double acosh(double x) {
+        return ACOSH.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return addExact(x, y).
+     */
+    public static int addExact(int x,
+                               int y) {
+        return ADDEXACT_INT.applyAsInt(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return addExact(x, y).
+     */
+    public static long addExact(long x,
+                                long y) {
+        return ADDEXACT_LONG.applyAsLong(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @return asin(x).
+     */
+    public static double asin(double x) {
+        return ASIN.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return asinh(x).
+     */
+    public static double asinh(double x) {
+        return ASINH.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return asin(x).
+     */
+    public static double atan(double x) {
+        return ATAN.applyAsDouble(x);
+    }
+
+    /**
+     * @param y Number.
+     * @param x Number.
+     * @return atan2(y, x).
+     */
+    public static double atan2(double y,
+                               double x) {
+        return ATAN2.applyAsDouble(y, x);
+    }
+
+    /**
+     * @param x Number.
+     * @return atanh(x).
+     */
+    public static double atanh(double x) {
+        return ATANH.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return cbrt(x).
+     */
+    public static double cbrt(double x) {
+        return CBRT.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return ceil(x).
+     */
+    public static double ceil(double x) {
+        return CEIL.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return copySign(x, y).
+     */
+    public static float copySign(float x,
+                                 float y) {
+        return COPYSIGN_FLOAT.applyAsFloat(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return copySign(x, y).
+     */
+    public static double copySign(double x,
+                                  double y) {
+        return COPYSIGN_DOUBLE.applyAsDouble(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @return cos(x).
+     */
+    public static double cos(double x) {
+        return COS.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return cosh(x).
+     */
+    public static double cosh(double x) {
+        return COSH.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return decrementExact(x).
+     */
+    public static int decrementExact(int x) {
+        return DECREMENTEXACT_INT.applyAsInt(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return decrementExact(x).
+     */
+    public static long decrementExact(long x) {
+        return DECREMENTEXACT_LONG.applyAsLong(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return exp(x).
+     */
+    public static double exp(double x) {
+        return EXP.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return expm1(x).
+     */
+    public static double expm1(double x) {
+        return EXPM1.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return floor(x).
+     */
+    public static double floor(double x) {
+        return FLOOR.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return floorDiv(x, y).
+     */
+    public static int floorDiv(int x,
+                               int y) {
+        return FLOORDIV_INT.applyAsInt(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return floorDiv(x, y).
+     */
+    public static long floorDiv(long x,
+                                long y) {
+        return FLOORDIV_LONG.applyAsLong(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return floorMod(x, y).
+     */
+    public static int floorMod(int x,
+                               int y) {
+        return FLOORMOD_INT.applyAsInt(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return floorMod(x, y).
+     */
+    public static long floorMod(long x,
+                                long y) {
+        return FLOORMOD_LONG.applyAsLong(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @return getExponent(x).
+     */
+    public static int getExponent(float x) {
+        return GETEXPONENT_FLOAT.applyAsInt(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return getExponent(x).
+     */
+    public static int getExponent(double x) {
+        return GETEXPONENT_DOUBLE.applyAsInt(x);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return hypot(x, y).
+     */
+    public static double hypot(double x,
+                               double y) {
+        return HYPOT.applyAsDouble(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return IEEEremainder(x, y).
+     */
+    public static double IEEEremainder(double x,
+                                       double y) {
+        return IEEEREMAINDER.applyAsDouble(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @return incrementExact(x).
+     */
+    public static int incrementExact(int x) {
+        return INCREMENTEXACT_INT.applyAsInt(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return incrementExact(x).
+     */
+    public static long incrementExact(long x) {
+        return INCREMENTEXACT_LONG.applyAsLong(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return log(x).
+     */
+    public static double log(double x) {
+        return LOG.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return log10(x).
+     */
+    public static double log10(double x) {
+        return LOG10.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return log1p(x).
+     */
+    public static double log1p(double x) {
+        return LOG1P.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return max(x, y).
+     */
+    public static int max(int x,
+                          int y) {
+        return MAX_INT.applyAsInt(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return max(x, y).
+     */
+    public static long max(long x,
+                           long y) {
+        return MAX_LONG.applyAsLong(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return max(x, y).
+     */
+    public static float max(float x,
+                            float y) {
+        return MAX_FLOAT.applyAsFloat(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return max(x, y).
+     */
+    public static double max(double x,
+                             double y) {
+        return MAX_DOUBLE.applyAsDouble(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return min(x, y).
+     */
+    public static int min(int x,
+                          int y) {
+        return MIN_INT.applyAsInt(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return min(x, y).
+     */
+    public static long min(long x,
+                           long y) {
+        return MIN_LONG.applyAsLong(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return min(x, y).
+     */
+    public static float min(float x,
+                            float y) {
+        return MIN_FLOAT.applyAsFloat(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return min(x, y).
+     */
+    public static double min(double x,
+                             double y) {
+        return MIN_DOUBLE.applyAsDouble(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return multiplyExact(x, y).
+     */
+    public static int multiplyExact(int x,
+                                    int y) {
+        return MULTIPLYEXACT_INT.applyAsInt(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return multiplyExact(x, y).
+     */
+    public static long multiplyExact(long x,
+                                     long y) {
+        return MULTIPLYEXACT_LONG.applyAsLong(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @return negateExact(x).
+     */
+    public static int negateExact(int x) {
+        return NEGATEEXACT_INT.applyAsInt(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return negateExact(x).
+     */
+    public static long negateExact(long x) {
+        return NEGATEEXACT_LONG.applyAsLong(x);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return nextAfter(x, y).
+     */
+    public static double nextAfter(double x,
+                                   double y) {
+        return NEXTAFTER_DOUBLE.applyAsDouble(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return nextAfter(x, y).
+     */
+    public static float nextAfter(float x,
+                                  double y) {
+        return NEXTAFTER_FLOAT.applyAsFloat(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @return nextDown(x).
+     */
+    public static double nextDown(double x) {
+        return NEXTDOWN_DOUBLE.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return nextDown(x).
+     */
+    public static float nextDown(float x) {
+        return NEXTDOWN_FLOAT.applyAsFloat(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return nextUp(x).
+     */
+    public static double nextUp(double x) {
+        return NEXTUP_DOUBLE.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return nextUp(x).
+     */
+    public static float nextUp(float x) {
+        return NEXTUP_FLOAT.applyAsFloat(x);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return pow(x, y).
+     */
+    public static double pow(double x,
+                             double y) {
+        return POW.applyAsDouble(x, y);
+    }
+
+    /**
+     * @return a random number between 0 and 1.
+     */
+    public static double random() {
+        return RANDOM.getAsDouble();
+    }
+
+    /**
+     * @param x Number.
+     * @return rint(x).
+     */
+    public static double rint(double x) {
+        return RINT.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return round(x).
+     */
+    public static int round(float x) {
+        return ROUND_FLOAT.applyAsInt(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return round(x).
+     */
+    public static long round(double x) {
+        return ROUND_DOUBLE.applyAsLong(x);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return scalb(x, y).
+     */
+    public static double scalb(double x,
+                               int y) {
+        return SCALB_DOUBLE.applyAsDouble(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return scalb(x, y).
+     */
+    public static float scalb(float x,
+                              int y) {
+        return SCALB_FLOAT.applyAsFloat(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @return signum(x).
+     */
+    public static double signum(double x) {
+        return SIGNUM_DOUBLE.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return signum(x).
+     */
+    public static float signum(float x) {
+        return SIGNUM_FLOAT.applyAsFloat(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return sin(x).
+     */
+    public static double sin(double x) {
+        return SIN.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return sinh(x).
+     */
+    public static double sinh(double x) {
+        return SINH.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return sqrt(x).
+     */
+    public static double sqrt(double x) {
+        return SQRT.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return subtractExact(x, y).
+     */
+    public static int subtractExact(int x,
+                                    int y) {
+        return SUBTRACTEXACT_INT.applyAsInt(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @param y Number.
+     * @return subtractExact(x, y).
+     */
+    public static long subtractExact(long x,
+                                     long y) {
+        return SUBTRACTEXACT_LONG.applyAsLong(x, y);
+    }
+
+    /**
+     * @param x Number.
+     * @return tan(x).
+     */
+    public static double tan(double x) {
+        return TAN.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return tanh(x).
+     */
+    public static double tanh(double x) {
+        return TANH.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return toDegrees(x).
+     */
+    public static double toDegrees(double x) {
+        return TODEGREES.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return toIntExact(x).
+     */
+    public static int toIntExact(long x) {
+        return TOINTEXACT.applyAsInt(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return toRadians(x).
+     */
+    public static double toRadians(double x) {
+        return TORADIANS.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return ulp(x).
+     */
+    public static double ulp(double x) {
+        return ULP_DOUBLE.applyAsDouble(x);
+    }
+
+    /**
+     * @param x Number.
+     * @return ulp(x).
+     */
+    public static float ulp(float x) {
+        return ULP_FLOAT.applyAsFloat(x);
+    }
+
+    /** Interface missing from "java.util.function" package. */
+    private interface FloatUnaryOperator {
+        /**
+         * @param x Operand.
+         * @return the result of applying this operator.
+         */
+        float applyAsFloat(float x);
+    }
+
+    /** Interface missing from "java.util.function" package. */
+    private interface FloatBinaryOperator {
+        /**
+         * @param x Operand.
+         * @param y Operand.
+         * @return the result of applying this operator.
+         */
+        float applyAsFloat(float x, float y);
+    }
+
+    /** Interface missing from "java.util.function" package. */
+    private interface FloatDouble2FloatOperator {
+        /**
+         * @param x Operand.
+         * @param y Operand.
+         * @return the result of applying this operator.
+         */
+        float applyAsFloat(float x, double y);
+    }
+
+    /** Interface missing from "java.util.function" package. */
+    private interface FloatToIntFunction {
+        /**
+         * @param x Operand.
+         * @return the result of applying this operator.
+         */
+        int applyAsInt(float x);
+    }
+
+    /** Interface missing from "java.util.function" package. */
+    private interface FloatInt2FloatOperator {
+        /**
+         * @param x Operand.
+         * @param y Operand.
+         * @return the result of applying this operator.
+         */
+        float applyAsFloat(float x, int y);
+    }
+
+    /** Interface missing from "java.util.function" package. */
+    private interface DoubleInt2DoubleOperator {
+        /**
+         * @param x Operand.
+         * @param y Operand.
+         * @return the result of applying this operator.
+         */
+        double applyAsDouble(double x, int y);
+    }
+}
diff --git a/commons-math-legacy-core/pom.xml b/commons-math-legacy-core/pom.xml
index 01110e6..759734d 100644
--- a/commons-math-legacy-core/pom.xml
+++ b/commons-math-legacy-core/pom.xml
@@ -46,6 +46,11 @@
 
     <dependency>
       <groupId>org.apache.commons</groupId>
+      <artifactId>commons-math4-core</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>org.apache.commons</groupId>
       <artifactId>commons-math4-legacy-exception</artifactId>
     </dependency>
 
diff --git a/commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/MathArrays.java b/commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/MathArrays.java
index d92362b..7b4284b 100644
--- a/commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/MathArrays.java
+++ b/commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/MathArrays.java
@@ -35,7 +35,7 @@
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Arrays utilities.
@@ -192,7 +192,7 @@
         checkEqualLength(p1, p2);
         double sum = 0;
         for (int i = 0; i < p1.length; i++) {
-            sum += AccurateMath.abs(p1[i] - p2[i]);
+            sum += JdkMath.abs(p1[i] - p2[i]);
         }
         return sum;
     }
@@ -209,7 +209,7 @@
         checkEqualLength(p1, p2);
         int sum = 0;
         for (int i = 0; i < p1.length; i++) {
-            sum += AccurateMath.abs(p1[i] - p2[i]);
+            sum += JdkMath.abs(p1[i] - p2[i]);
         }
         return sum;
     }
@@ -229,7 +229,7 @@
             final double dp = p1[i] - p2[i];
             sum += dp * dp;
         }
-        return AccurateMath.sqrt(sum);
+        return JdkMath.sqrt(sum);
     }
 
     /**
@@ -247,7 +247,7 @@
             final double dp = (double) p1[i] - p2[i];
             sum += dp * dp;
         }
-        return AccurateMath.sqrt(sum);
+        return JdkMath.sqrt(sum);
     }
 
     /**
@@ -262,7 +262,7 @@
         checkEqualLength(p1, p2);
         double max = 0;
         for (int i = 0; i < p1.length; i++) {
-            max = AccurateMath.max(max, AccurateMath.abs(p1[i] - p2[i]));
+            max = JdkMath.max(max, JdkMath.abs(p1[i] - p2[i]));
         }
         return max;
     }
@@ -279,7 +279,7 @@
         checkEqualLength(p1, p2);
         int max = 0;
         for (int i = 0; i < p1.length; i++) {
-            max = AccurateMath.max(max, AccurateMath.abs(p1[i] - p2[i]));
+            max = JdkMath.max(max, JdkMath.abs(p1[i] - p2[i]));
         }
         return max;
     }
@@ -845,7 +845,7 @@
         // straightforward implementation of the convolution sum
         for (int n = 0; n < totalLength; n++) {
             double yn = 0;
-            int k = AccurateMath.max(0, n + 1 - xLen);
+            int k = JdkMath.max(0, n + 1 - xLen);
             int j = n - k;
             while (k < hLen && j >= 0) {
                 yn += x[j--] * h[k++];
diff --git a/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/ExtendedFieldElementAbstractTest.java b/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/ExtendedFieldElementAbstractTest.java
index c2bb57e..4f1f358 100644
--- a/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/ExtendedFieldElementAbstractTest.java
+++ b/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/ExtendedFieldElementAbstractTest.java
@@ -22,7 +22,7 @@
 import org.apache.commons.numbers.core.Sum;
 import org.apache.commons.rng.UniformRandomProvider;
 import org.apache.commons.rng.simple.RandomSource;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 public abstract class ExtendedFieldElementAbstractTest<T extends RealFieldElement<T>> {
 
@@ -113,7 +113,7 @@
     public void testRemainderField() {
         for (double x = -3; x < 3; x += 0.2) {
             for (double y = -3; y < 3; y += 0.2) {
-                checkRelative(AccurateMath.IEEEremainder(x, y), build(x).remainder(build(y)));
+                checkRelative(JdkMath.IEEEremainder(x, y), build(x).remainder(build(y)));
             }
         }
     }
@@ -122,7 +122,7 @@
     public void testRemainderDouble() {
         for (double x = -3; x < 3; x += 0.2) {
             for (double y = -3.2; y < 3.2; y += 0.25) {
-                checkRelative(AccurateMath.IEEEremainder(x, y), build(x).remainder(y));
+                checkRelative(JdkMath.IEEEremainder(x, y), build(x).remainder(y));
             }
         }
     }
@@ -130,42 +130,42 @@
     @Test
     public void testCos() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.cos(x), build(x).cos());
+            checkRelative(JdkMath.cos(x), build(x).cos());
         }
     }
 
     @Test
     public void testAcos() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.acos(x), build(x).acos());
+            checkRelative(JdkMath.acos(x), build(x).acos());
         }
     }
 
     @Test
     public void testSin() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.sin(x), build(x).sin());
+            checkRelative(JdkMath.sin(x), build(x).sin());
         }
     }
 
     @Test
     public void testAsin() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.asin(x), build(x).asin());
+            checkRelative(JdkMath.asin(x), build(x).asin());
         }
     }
 
     @Test
     public void testTan() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.tan(x), build(x).tan());
+            checkRelative(JdkMath.tan(x), build(x).tan());
         }
     }
 
     @Test
     public void testAtan() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.atan(x), build(x).atan());
+            checkRelative(JdkMath.atan(x), build(x).atan());
         }
     }
 
@@ -173,7 +173,7 @@
     public void testAtan2() {
         for (double x = -3; x < 3; x += 0.2) {
             for (double y = -3; y < 3; y += 0.2) {
-                checkRelative(AccurateMath.atan2(x, y), build(x).atan2(build(y)));
+                checkRelative(JdkMath.atan2(x, y), build(x).atan2(build(y)));
             }
         }
     }
@@ -181,56 +181,56 @@
     @Test
     public void testCosh() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.cosh(x), build(x).cosh());
+            checkRelative(JdkMath.cosh(x), build(x).cosh());
         }
     }
 
     @Test
     public void testAcosh() {
         for (double x = 1.1; x < 5.0; x += 0.05) {
-            checkRelative(AccurateMath.acosh(x), build(x).acosh());
+            checkRelative(JdkMath.acosh(x), build(x).acosh());
         }
     }
 
     @Test
     public void testSinh() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.sinh(x), build(x).sinh());
+            checkRelative(JdkMath.sinh(x), build(x).sinh());
         }
     }
 
     @Test
     public void testAsinh() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.asinh(x), build(x).asinh());
+            checkRelative(JdkMath.asinh(x), build(x).asinh());
         }
     }
 
     @Test
     public void testTanh() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.tanh(x), build(x).tanh());
+            checkRelative(JdkMath.tanh(x), build(x).tanh());
         }
     }
 
     @Test
     public void testAtanh() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.atanh(x), build(x).atanh());
+            checkRelative(JdkMath.atanh(x), build(x).atanh());
         }
     }
 
     @Test
     public void testSqrt() {
         for (double x = 0.01; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.sqrt(x), build(x).sqrt());
+            checkRelative(JdkMath.sqrt(x), build(x).sqrt());
         }
     }
 
     @Test
     public void testCbrt() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.cbrt(x), build(x).cbrt());
+            checkRelative(JdkMath.cbrt(x), build(x).cbrt());
         }
     }
 
@@ -238,7 +238,7 @@
     public void testHypot() {
         for (double x = -3; x < 3; x += 0.2) {
             for (double y = -3; y < 3; y += 0.2) {
-                checkRelative(AccurateMath.hypot(x, y), build(x).hypot(build(y)));
+                checkRelative(JdkMath.hypot(x, y), build(x).hypot(build(y)));
             }
         }
     }
@@ -249,10 +249,10 @@
             for (int n = 1; n < 5; ++n) {
                 if (x < 0) {
                     if (n % 2 == 1) {
-                        checkRelative(-AccurateMath.pow(-x, 1.0 / n), build(x).rootN(n));
+                        checkRelative(-JdkMath.pow(-x, 1.0 / n), build(x).rootN(n));
                     }
                 } else {
-                    checkRelative(AccurateMath.pow(x, 1.0 / n), build(x).rootN(n));
+                    checkRelative(JdkMath.pow(x, 1.0 / n), build(x).rootN(n));
                 }
             }
         }
@@ -262,7 +262,7 @@
     public void testPowField() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
             for (double y = 0.1; y < 4; y += 0.2) {
-                checkRelative(AccurateMath.pow(x, y), build(x).pow(build(y)));
+                checkRelative(JdkMath.pow(x, y), build(x).pow(build(y)));
             }
         }
     }
@@ -271,7 +271,7 @@
     public void testPowDouble() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
             for (double y = 0.1; y < 4; y += 0.2) {
-                checkRelative(AccurateMath.pow(x, y), build(x).pow(y));
+                checkRelative(JdkMath.pow(x, y), build(x).pow(y));
             }
         }
     }
@@ -280,7 +280,7 @@
     public void testPowInt() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
             for (int n = 0; n < 5; ++n) {
-                checkRelative(AccurateMath.pow(x, n), build(x).pow(n));
+                checkRelative(JdkMath.pow(x, n), build(x).pow(n));
             }
         }
     }
@@ -288,77 +288,77 @@
     @Test
     public void testExp() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.exp(x), build(x).exp());
+            checkRelative(JdkMath.exp(x), build(x).exp());
         }
     }
 
     @Test
     public void testExpm1() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.expm1(x), build(x).expm1());
+            checkRelative(JdkMath.expm1(x), build(x).expm1());
         }
     }
 
     @Test
     public void testLog() {
         for (double x = 0.01; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.log(x), build(x).log());
+            checkRelative(JdkMath.log(x), build(x).log());
         }
     }
 
     @Test
     public void testLog1p() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.log1p(x), build(x).log1p());
+            checkRelative(JdkMath.log1p(x), build(x).log1p());
         }
     }
 
     @Test
     public void testLog10() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.log10(x), build(x).log10());
+            checkRelative(JdkMath.log10(x), build(x).log10());
         }
     }
 
     @Test
     public void testAbs() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.abs(x), build(x).abs());
+            checkRelative(JdkMath.abs(x), build(x).abs());
         }
     }
 
     @Test
     public void testCeil() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.ceil(x), build(x).ceil());
+            checkRelative(JdkMath.ceil(x), build(x).ceil());
         }
     }
 
     @Test
     public void testFloor() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.floor(x), build(x).floor());
+            checkRelative(JdkMath.floor(x), build(x).floor());
         }
     }
 
     @Test
     public void testRint() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.rint(x), build(x).rint());
+            checkRelative(JdkMath.rint(x), build(x).rint());
         }
     }
 
     @Test
     public void testRound() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            Assert.assertEquals(AccurateMath.round(x), build(x).round());
+            Assert.assertEquals(JdkMath.round(x), build(x).round());
         }
     }
 
     @Test
     public void testSignum() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
-            checkRelative(AccurateMath.signum(x), build(x).signum());
+            checkRelative(JdkMath.signum(x), build(x).signum());
         }
     }
 
@@ -366,7 +366,7 @@
     public void testCopySignField() {
         for (double x = -3; x < 3; x += 0.2) {
             for (double y = -3; y < 3; y += 0.2) {
-                checkRelative(AccurateMath.copySign(x, y), build(x).copySign(build(y)));
+                checkRelative(JdkMath.copySign(x, y), build(x).copySign(build(y)));
             }
         }
     }
@@ -375,7 +375,7 @@
     public void testCopySignDouble() {
         for (double x = -3; x < 3; x += 0.2) {
             for (double y = -3; y < 3; y += 0.2) {
-                checkRelative(AccurateMath.copySign(x, y), build(x).copySign(y));
+                checkRelative(JdkMath.copySign(x, y), build(x).copySign(y));
             }
         }
     }
@@ -384,7 +384,7 @@
     public void testScalb() {
         for (double x = -0.9; x < 0.9; x += 0.05) {
             for (int n = -100; n < 100; ++n) {
-                checkRelative(AccurateMath.scalb(x, n), build(x).scalb(n));
+                checkRelative(JdkMath.scalb(x, n), build(x).scalb(n));
             }
         }
     }
@@ -514,7 +514,7 @@
     }
 
     private void checkRelative(double expected, T obtained) {
-        Assert.assertEquals(expected, obtained.getReal(), 1.0e-15 * (1 + AccurateMath.abs(expected)));
+        Assert.assertEquals(expected, obtained.getReal(), 1.0e-15 * (1 + JdkMath.abs(expected)));
     }
 
     @Test
diff --git a/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/MathArraysTest.java b/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/MathArraysTest.java
index 0a95cb0..16500e4 100644
--- a/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/MathArraysTest.java
+++ b/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/MathArraysTest.java
@@ -31,7 +31,7 @@
 import org.apache.commons.math4.legacy.exception.NotPositiveException;
 import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Test cases for the {@link MathArrays} class.
@@ -394,7 +394,7 @@
                                      -Double.MAX_VALUE,
                                      -1, 0,
                                      Double.MIN_VALUE,
-                                     AccurateMath.ulp(1d),
+                                     JdkMath.ulp(1d),
                                      1, 3, 113, 4769,
                                      Double.MAX_VALUE,
                                      Double.POSITIVE_INFINITY };
@@ -403,7 +403,7 @@
                                   -Double.MAX_VALUE,
                                   -1, 0,
                                   Double.MIN_VALUE,
-                                  AccurateMath.ulp(1d),
+                                  JdkMath.ulp(1d),
                                   1, 3, 113, 4769,
                                   Double.MAX_VALUE,
                                   Double.POSITIVE_INFINITY,
@@ -458,7 +458,7 @@
         Assert.assertFalse(MathArrays.equals(new double[] {Double.POSITIVE_INFINITY},
                                              new double[] {Double.NEGATIVE_INFINITY}));
         Assert.assertFalse(MathArrays.equals(new double[] {1d},
-                                             new double[] {AccurateMath.nextAfter(AccurateMath.nextAfter(1d, 2d), 2d)}));
+                                             new double[] {JdkMath.nextAfter(JdkMath.nextAfter(1d, 2d), 2d)}));
 
     }
 
@@ -477,7 +477,7 @@
         Assert.assertFalse(MathArrays.equalsIncludingNaN(new double[] {Double.POSITIVE_INFINITY},
                                                          new double[] {Double.NEGATIVE_INFINITY}));
         Assert.assertFalse(MathArrays.equalsIncludingNaN(new double[] {1d},
-                                                         new double[] {AccurateMath.nextAfter(AccurateMath.nextAfter(1d, 2d), 2d)}));
+                                                         new double[] {JdkMath.nextAfter(JdkMath.nextAfter(1d, 2d), 2d)}));
     }
 
     @Test
diff --git a/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/dfp/DfpTest.java b/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/dfp/DfpTest.java
index 6f1d21a..3670b57 100644
--- a/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/dfp/DfpTest.java
+++ b/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/dfp/DfpTest.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.core.dfp;
 
 import org.apache.commons.math4.legacy.core.ExtendedFieldElementAbstractTest;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.numbers.core.Precision;
 import org.junit.After;
 import org.junit.Assert;
@@ -1570,8 +1570,8 @@
         DfpField localField = new DfpField(100);
         Assert.assertEquals(0.0, localField.getZero().toDouble(), Precision.SAFE_MIN);
         Assert.assertEquals(0.0, localField.newDfp(0.0).toDouble(), Precision.SAFE_MIN);
-        Assert.assertEquals(-1, AccurateMath.copySign(1, localField.newDfp(-0.0).toDouble()), Precision.EPSILON);
-        Assert.assertEquals(+1, AccurateMath.copySign(1, localField.newDfp(+0.0).toDouble()), Precision.EPSILON);
+        Assert.assertEquals(-1, JdkMath.copySign(1, localField.newDfp(-0.0).toDouble()), Precision.EPSILON);
+        Assert.assertEquals(+1, JdkMath.copySign(1, localField.newDfp(+0.0).toDouble()), Precision.EPSILON);
     }
 
     @Test
diff --git a/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMathStrictComparisonTest.java b/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMathStrictComparisonTest.java
index baf2b3a..7714e23 100644
--- a/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMathStrictComparisonTest.java
+++ b/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMathStrictComparisonTest.java
@@ -31,6 +31,10 @@
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
 
+// Unit test should be moved to module "commons-math-core".
+// [Currently, it can't be because it depends on "legacy" classes.]
+import org.apache.commons.math4.core.jdkmath.AccurateMath;
+
 /**
  * Test to compare AccurateMath results against StrictMath results for boundary values.
  * <p>
diff --git a/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMathTest.java b/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMathTest.java
index 2775211..fbfe40c 100644
--- a/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMathTest.java
+++ b/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMathTest.java
@@ -40,9 +40,13 @@
 import org.apache.commons.rng.UniformRandomProvider;
 import org.apache.commons.rng.simple.RandomSource;
 
+// Unit test should be moved to module "commons-math-core".
+// [Currently, it can't be because it depends on "legacy" classes.]
+import org.apache.commons.math4.core.jdkmath.AccurateMath;
+
 public class AccurateMathTest {
     // CHECKSTYLE: stop Regexp
-    // The above comment allowa System.out.print
+    // The above comment allows System.out.print
 
     private static final double MAX_ERROR_ULP = 0.51;
     private static final int NUMBER_OF_TRIALS = 1000;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/DSCompiler.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/DSCompiler.java
index dc19319..6d85b98 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/DSCompiler.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/DSCompiler.java
@@ -28,7 +28,7 @@
 import org.apache.commons.math4.legacy.exception.NotPositiveException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
 import org.apache.commons.numbers.combinatorics.FactorialDouble;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /** Class holding "compiled" computation rules for derivative structures.
  * <p>This class implements the computation rules described in Dan Kalman's paper <a
@@ -199,8 +199,8 @@
         }
 
         // we need to create more compilers
-        final int maxParameters = AccurateMath.max(parameters, cache == null ? 0 : cache.length);
-        final int maxOrder      = AccurateMath.max(order,     cache == null ? 0 : cache[0].length);
+        final int maxParameters = JdkMath.max(parameters, cache == null ? 0 : cache.length);
+        final int maxOrder      = JdkMath.max(order,     cache == null ? 0 : cache[0].length);
         final DSCompiler[][] newCache = new DSCompiler[maxParameters + 1][maxOrder + 1];
 
         if (cache != null) {
@@ -212,7 +212,7 @@
 
         // create the array in increasing diagonal order
         for (int diag = 0; diag <= parameters + order; ++diag) {
-            for (int o = AccurateMath.max(0, diag - parameters); o <= AccurateMath.min(order, diag); ++o) {
+            for (int o = JdkMath.max(0, diag - parameters); o <= JdkMath.min(order, diag); ++o) {
                 final int p = diag - o;
                 if (newCache[p][o] == null) {
                     final DSCompiler valueCompiler      = (p == 0) ? null : newCache[p - 1][o];
@@ -610,7 +610,7 @@
                                     final int destP, final int destO, final int[][] destSizes)
         throws NumberIsTooLargeException {
         int[] orders = new int[destP];
-        System.arraycopy(srcDerivativesIndirection[index], 0, orders, 0, AccurateMath.min(srcP, destP));
+        System.arraycopy(srcDerivativesIndirection[index], 0, orders, 0, JdkMath.min(srcP, destP));
         return getPartialDerivativeIndex(destP, destO, destSizes, orders);
     }
 
@@ -822,8 +822,8 @@
                           final double[] result, final int resultOffset) {
 
         // compute k such that lhs % rhs = lhs - k rhs
-        final double rem = AccurateMath.IEEEremainder(lhs[lhsOffset], rhs[rhsOffset]);
-        final double k   = AccurateMath.rint((lhs[lhsOffset] - rem) / rhs[rhsOffset]);
+        final double rem = JdkMath.IEEEremainder(lhs[lhsOffset], rhs[rhsOffset]);
+        final double k   = JdkMath.rint((lhs[lhsOffset] - rem) / rhs[rhsOffset]);
 
         // set up value
         result[resultOffset] = rem;
@@ -864,8 +864,8 @@
                 Arrays.fill(function, Double.NaN);
             }
         } else {
-            function[0] = AccurateMath.pow(a, operand[operandOffset]);
-            final double lnA = AccurateMath.log(a);
+            function[0] = JdkMath.pow(a, operand[operandOffset]);
+            final double lnA = JdkMath.log(a);
             for (int i = 1; i < function.length; ++i) {
                 function[i] = lnA * function[i - 1];
             }
@@ -905,7 +905,7 @@
         // create the function value and derivatives
         // [x^p, px^(p-1), p(p-1)x^(p-2), ... ]
         double[] function = new double[1 + order];
-        double xk = AccurateMath.pow(operand[operandOffset], p - order);
+        double xk = JdkMath.pow(operand[operandOffset], p - order);
         for (int i = order; i > 0; --i) {
             function[i] = xk;
             xk *= operand[operandOffset];
@@ -947,8 +947,8 @@
 
         if (n > 0) {
             // strictly positive power
-            final int maxOrder = AccurateMath.min(order, n);
-            double xk = AccurateMath.pow(operand[operandOffset], n - maxOrder);
+            final int maxOrder = JdkMath.min(order, n);
+            double xk = JdkMath.pow(operand[operandOffset], n - maxOrder);
             for (int i = maxOrder; i > 0; --i) {
                 function[i] = xk;
                 xk *= operand[operandOffset];
@@ -957,7 +957,7 @@
         } else {
             // strictly negative power
             final double inv = 1.0 / operand[operandOffset];
-            double xk = AccurateMath.pow(inv, -n);
+            double xk = JdkMath.pow(inv, -n);
             for (int i = 0; i <= order; ++i) {
                 function[i] = xk;
                 xk *= inv;
@@ -1012,14 +1012,14 @@
         double[] function = new double[1 + order];
         double xk;
         if (n == 2) {
-            function[0] = AccurateMath.sqrt(operand[operandOffset]);
+            function[0] = JdkMath.sqrt(operand[operandOffset]);
             xk          = 0.5 / function[0];
         } else if (n == 3) {
-            function[0] = AccurateMath.cbrt(operand[operandOffset]);
+            function[0] = JdkMath.cbrt(operand[operandOffset]);
             xk          = 1.0 / (3.0 * function[0] * function[0]);
         } else {
-            function[0] = AccurateMath.pow(operand[operandOffset], 1.0 / n);
-            xk          = 1.0 / (n * AccurateMath.pow(function[0], n - 1));
+            function[0] = JdkMath.pow(operand[operandOffset], 1.0 / n);
+            xk          = 1.0 / (n * JdkMath.pow(function[0], n - 1));
         }
         final double nReciprocal = 1.0 / n;
         final double xReciprocal = 1.0 / operand[operandOffset];
@@ -1046,7 +1046,7 @@
 
         // create the function value and derivatives
         double[] function = new double[1 + order];
-        Arrays.fill(function, AccurateMath.exp(operand[operandOffset]));
+        Arrays.fill(function, JdkMath.exp(operand[operandOffset]));
 
         // apply function composition
         compose(operand, operandOffset, function, result, resultOffset);
@@ -1066,8 +1066,8 @@
 
         // create the function value and derivatives
         double[] function = new double[1 + order];
-        function[0] = AccurateMath.expm1(operand[operandOffset]);
-        Arrays.fill(function, 1, 1 + order, AccurateMath.exp(operand[operandOffset]));
+        function[0] = JdkMath.expm1(operand[operandOffset]);
+        Arrays.fill(function, 1, 1 + order, JdkMath.exp(operand[operandOffset]));
 
         // apply function composition
         compose(operand, operandOffset, function, result, resultOffset);
@@ -1087,7 +1087,7 @@
 
         // create the function value and derivatives
         double[] function = new double[1 + order];
-        function[0] = AccurateMath.log(operand[operandOffset]);
+        function[0] = JdkMath.log(operand[operandOffset]);
         if (order > 0) {
             double inv = 1.0 / operand[operandOffset];
             double xk  = inv;
@@ -1114,7 +1114,7 @@
 
         // create the function value and derivatives
         double[] function = new double[1 + order];
-        function[0] = AccurateMath.log1p(operand[operandOffset]);
+        function[0] = JdkMath.log1p(operand[operandOffset]);
         if (order > 0) {
             double inv = 1.0 / (1.0 + operand[operandOffset]);
             double xk  = inv;
@@ -1141,10 +1141,10 @@
 
         // create the function value and derivatives
         double[] function = new double[1 + order];
-        function[0] = AccurateMath.log10(operand[operandOffset]);
+        function[0] = JdkMath.log10(operand[operandOffset]);
         if (order > 0) {
             double inv = 1.0 / operand[operandOffset];
-            double xk  = inv / AccurateMath.log(10.0);
+            double xk  = inv / JdkMath.log(10.0);
             for (int i = 1; i <= order; ++i) {
                 function[i] = xk;
                 xk *= -i * inv;
@@ -1169,9 +1169,9 @@
 
         // create the function value and derivatives
         double[] function = new double[1 + order];
-        function[0] = AccurateMath.cos(operand[operandOffset]);
+        function[0] = JdkMath.cos(operand[operandOffset]);
         if (order > 0) {
-            function[1] = -AccurateMath.sin(operand[operandOffset]);
+            function[1] = -JdkMath.sin(operand[operandOffset]);
             for (int i = 2; i <= order; ++i) {
                 function[i] = -function[i - 2];
             }
@@ -1195,9 +1195,9 @@
 
         // create the function value and derivatives
         double[] function = new double[1 + order];
-        function[0] = AccurateMath.sin(operand[operandOffset]);
+        function[0] = JdkMath.sin(operand[operandOffset]);
         if (order > 0) {
-            function[1] = AccurateMath.cos(operand[operandOffset]);
+            function[1] = JdkMath.cos(operand[operandOffset]);
             for (int i = 2; i <= order; ++i) {
                 function[i] = -function[i - 2];
             }
@@ -1221,7 +1221,7 @@
 
         // create the function value and derivatives
         final double[] function = new double[1 + order];
-        final double t = AccurateMath.tan(operand[operandOffset]);
+        final double t = JdkMath.tan(operand[operandOffset]);
         function[0] = t;
 
         if (order > 0) {
@@ -1277,7 +1277,7 @@
         // create the function value and derivatives
         double[] function = new double[1 + order];
         final double x = operand[operandOffset];
-        function[0] = AccurateMath.acos(x);
+        function[0] = JdkMath.acos(x);
         if (order > 0) {
             // the nth order derivative of acos has the form:
             // dn(acos(x)/dxn = P_n(x) / [1 - x^2]^((2n-1)/2)
@@ -1290,7 +1290,7 @@
             p[0] = -1;
             final double x2    = x * x;
             final double f     = 1.0 / (1 - x2);
-            double coeff = AccurateMath.sqrt(f);
+            double coeff = JdkMath.sqrt(f);
             function[1] = coeff * p[0];
             for (int n = 2; n <= order; ++n) {
 
@@ -1334,7 +1334,7 @@
         // create the function value and derivatives
         double[] function = new double[1 + order];
         final double x = operand[operandOffset];
-        function[0] = AccurateMath.asin(x);
+        function[0] = JdkMath.asin(x);
         if (order > 0) {
             // the nth order derivative of asin has the form:
             // dn(asin(x)/dxn = P_n(x) / [1 - x^2]^((2n-1)/2)
@@ -1347,7 +1347,7 @@
             p[0] = 1;
             final double x2    = x * x;
             final double f     = 1.0 / (1 - x2);
-            double coeff = AccurateMath.sqrt(f);
+            double coeff = JdkMath.sqrt(f);
             function[1] = coeff * p[0];
             for (int n = 2; n <= order; ++n) {
 
@@ -1391,7 +1391,7 @@
         // create the function value and derivatives
         double[] function = new double[1 + order];
         final double x = operand[operandOffset];
-        function[0] = AccurateMath.atan(x);
+        function[0] = JdkMath.atan(x);
         if (order > 0) {
             // the nth order derivative of atan has the form:
             // dn(atan(x)/dxn = Q_n(x) / (1 + x^2)^n
@@ -1473,7 +1473,7 @@
             divide(y, yOffset, tmp2, 0, tmp1, 0);       // y /(r - x)
             atan(tmp1, 0, tmp2, 0);                     // atan(y / (r - x))
             result[resultOffset] =
-                    ((tmp2[0] <= 0) ? -AccurateMath.PI : AccurateMath.PI) - 2 * tmp2[0]; // +/-pi - 2 * atan(y / (r - x))
+                    ((tmp2[0] <= 0) ? -JdkMath.PI : JdkMath.PI) - 2 * tmp2[0]; // +/-pi - 2 * atan(y / (r - x))
             for (int i = 1; i < tmp2.length; ++i) {
                 result[resultOffset + i] = -2 * tmp2[i]; // +/-pi - 2 * atan(y / (r - x))
             }
@@ -1481,7 +1481,7 @@
         }
 
         // fix value to take special cases (+0/+0, +0/-0, -0/+0, -0/-0, +/-infinity) correctly
-        result[resultOffset] = AccurateMath.atan2(y[yOffset], x[xOffset]);
+        result[resultOffset] = JdkMath.atan2(y[yOffset], x[xOffset]);
 
     }
 
@@ -1498,9 +1498,9 @@
 
         // create the function value and derivatives
         double[] function = new double[1 + order];
-        function[0] = AccurateMath.cosh(operand[operandOffset]);
+        function[0] = JdkMath.cosh(operand[operandOffset]);
         if (order > 0) {
-            function[1] = AccurateMath.sinh(operand[operandOffset]);
+            function[1] = JdkMath.sinh(operand[operandOffset]);
             for (int i = 2; i <= order; ++i) {
                 function[i] = function[i - 2];
             }
@@ -1524,9 +1524,9 @@
 
         // create the function value and derivatives
         double[] function = new double[1 + order];
-        function[0] = AccurateMath.sinh(operand[operandOffset]);
+        function[0] = JdkMath.sinh(operand[operandOffset]);
         if (order > 0) {
-            function[1] = AccurateMath.cosh(operand[operandOffset]);
+            function[1] = JdkMath.cosh(operand[operandOffset]);
             for (int i = 2; i <= order; ++i) {
                 function[i] = function[i - 2];
             }
@@ -1550,7 +1550,7 @@
 
         // create the function value and derivatives
         final double[] function = new double[1 + order];
-        final double t = AccurateMath.tanh(operand[operandOffset]);
+        final double t = JdkMath.tanh(operand[operandOffset]);
         function[0] = t;
 
         if (order > 0) {
@@ -1606,7 +1606,7 @@
         // create the function value and derivatives
         double[] function = new double[1 + order];
         final double x = operand[operandOffset];
-        function[0] = AccurateMath.acosh(x);
+        function[0] = JdkMath.acosh(x);
         if (order > 0) {
             // the nth order derivative of acosh has the form:
             // dn(acosh(x)/dxn = P_n(x) / [x^2 - 1]^((2n-1)/2)
@@ -1619,7 +1619,7 @@
             p[0] = 1;
             final double x2  = x * x;
             final double f   = 1.0 / (x2 - 1);
-            double coeff = AccurateMath.sqrt(f);
+            double coeff = JdkMath.sqrt(f);
             function[1] = coeff * p[0];
             for (int n = 2; n <= order; ++n) {
 
@@ -1663,7 +1663,7 @@
         // create the function value and derivatives
         double[] function = new double[1 + order];
         final double x = operand[operandOffset];
-        function[0] = AccurateMath.asinh(x);
+        function[0] = JdkMath.asinh(x);
         if (order > 0) {
             // the nth order derivative of asinh has the form:
             // dn(asinh(x)/dxn = P_n(x) / [x^2 + 1]^((2n-1)/2)
@@ -1676,7 +1676,7 @@
             p[0] = 1;
             final double x2    = x * x;
             final double f     = 1.0 / (1 + x2);
-            double coeff = AccurateMath.sqrt(f);
+            double coeff = JdkMath.sqrt(f);
             function[1] = coeff * p[0];
             for (int n = 2; n <= order; ++n) {
 
@@ -1720,7 +1720,7 @@
         // create the function value and derivatives
         double[] function = new double[1 + order];
         final double x = operand[operandOffset];
-        function[0] = AccurateMath.atanh(x);
+        function[0] = JdkMath.atanh(x);
         if (order > 0) {
             // the nth order derivative of atanh has the form:
             // dn(atanh(x)/dxn = Q_n(x) / (1 - x^2)^n
@@ -1806,7 +1806,7 @@
             for (int k = 0; k < orders.length; ++k) {
                 if (orders[k] > 0) {
                     try {
-                        term *= AccurateMath.pow(delta[k], orders[k]) / FACTORIAL.value(orders[k]);
+                        term *= JdkMath.pow(delta[k], orders[k]) / FACTORIAL.value(orders[k]);
                     } catch (NotPositiveException e) {
                         // this cannot happen
                         throw new MathInternalError(e);
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/DerivativeStructure.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/DerivativeStructure.java
index 11fc04d..66c52b7 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/DerivativeStructure.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/DerivativeStructure.java
@@ -26,7 +26,7 @@
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
 import org.apache.commons.math4.legacy.exception.MathArithmeticException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 
 /** Class representing both the value and the differentials of a function.
@@ -389,7 +389,7 @@
     @Override
     public DerivativeStructure remainder(final double a) {
         final DerivativeStructure ds = new DerivativeStructure(this);
-        ds.data[0] = AccurateMath.IEEEremainder(ds.data[0], a);
+        ds.data[0] = JdkMath.IEEEremainder(ds.data[0], a);
         return ds;
     }
 
@@ -437,7 +437,7 @@
     public DerivativeStructure ceil() {
         return new DerivativeStructure(compiler.getFreeParameters(),
                                        compiler.getOrder(),
-                                       AccurateMath.ceil(data[0]));
+                                       JdkMath.ceil(data[0]));
     }
 
     /** {@inheritDoc}
@@ -447,7 +447,7 @@
     public DerivativeStructure floor() {
         return new DerivativeStructure(compiler.getFreeParameters(),
                                        compiler.getOrder(),
-                                       AccurateMath.floor(data[0]));
+                                       JdkMath.floor(data[0]));
     }
 
     /** {@inheritDoc}
@@ -457,13 +457,13 @@
     public DerivativeStructure rint() {
         return new DerivativeStructure(compiler.getFreeParameters(),
                                        compiler.getOrder(),
-                                       AccurateMath.rint(data[0]));
+                                       JdkMath.rint(data[0]));
     }
 
     /** {@inheritDoc} */
     @Override
     public long round() {
-        return AccurateMath.round(data[0]);
+        return JdkMath.round(data[0]);
     }
 
     /** {@inheritDoc}
@@ -473,7 +473,7 @@
     public DerivativeStructure signum() {
         return new DerivativeStructure(compiler.getFreeParameters(),
                                        compiler.getOrder(),
-                                       AccurateMath.signum(data[0]));
+                                       JdkMath.signum(data[0]));
     }
 
     /** {@inheritDoc}
@@ -511,7 +511,7 @@
      * @return exponent for instance in IEEE754 representation, without bias
      */
     public int getExponent() {
-        return AccurateMath.getExponent(data[0]);
+        return JdkMath.getExponent(data[0]);
     }
 
     /** {@inheritDoc}
@@ -521,7 +521,7 @@
     public DerivativeStructure scalb(final int n) {
         final DerivativeStructure ds = new DerivativeStructure(compiler);
         for (int i = 0; i < ds.data.length; ++i) {
-            ds.data[i] = AccurateMath.scalb(data[i], n);
+            ds.data[i] = JdkMath.scalb(data[i], n);
         }
         return ds;
     }
@@ -923,7 +923,7 @@
     public DerivativeStructure toDegrees() {
         final DerivativeStructure ds = new DerivativeStructure(compiler);
         for (int i = 0; i < ds.data.length; ++i) {
-            ds.data[i] = AccurateMath.toDegrees(data[i]);
+            ds.data[i] = JdkMath.toDegrees(data[i]);
         }
         return ds;
     }
@@ -934,7 +934,7 @@
     public DerivativeStructure toRadians() {
         final DerivativeStructure ds = new DerivativeStructure(compiler);
         for (int i = 0; i < ds.data.length; ++i) {
-            ds.data[i] = AccurateMath.toRadians(data[i]);
+            ds.data[i] = JdkMath.toRadians(data[i]);
         }
         return ds;
     }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/FiniteDifferencesDifferentiator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/FiniteDifferencesDifferentiator.java
index 1441097..6aa3924 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/FiniteDifferencesDifferentiator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/FiniteDifferencesDifferentiator.java
@@ -25,7 +25,7 @@
 import org.apache.commons.math4.legacy.exception.NotPositiveException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /** Univariate functions differentiator using finite differences.
  * <p>
@@ -156,7 +156,7 @@
         if (2 * halfSampleSpan >= tUpper - tLower) {
             throw new NumberIsTooLargeException(2 * halfSampleSpan, tUpper - tLower, false);
         }
-        final double safety = AccurateMath.ulp(halfSampleSpan);
+        final double safety = JdkMath.ulp(halfSampleSpan);
         this.tMin = tLower + halfSampleSpan + safety;
         this.tMax = tUpper - halfSampleSpan - safety;
 
@@ -262,7 +262,7 @@
                 }
 
                 // compute sample position, trying to be centered if possible
-                final double t0 = AccurateMath.max(AccurateMath.min(t.getValue(), tMax), tMin) - halfSampleSpan;
+                final double t0 = JdkMath.max(JdkMath.min(t.getValue(), tMax), tMin) - halfSampleSpan;
 
                 // compute sample points
                 final double[] y = new double[nbPoints];
@@ -305,7 +305,7 @@
                 }
 
                 // compute sample position, trying to be centered if possible
-                final double t0 = AccurateMath.max(AccurateMath.min(t.getValue(), tMax), tMin) - halfSampleSpan;
+                final double t0 = JdkMath.max(JdkMath.min(t.getValue(), tMax), tMin) - halfSampleSpan;
 
                 // compute sample points
                 double[][] y = null;
@@ -359,7 +359,7 @@
                 }
 
                 // compute sample position, trying to be centered if possible
-                final double t0 = AccurateMath.max(AccurateMath.min(t.getValue(), tMax), tMin) - halfSampleSpan;
+                final double t0 = JdkMath.max(JdkMath.min(t.getValue(), tMax), tMin) - halfSampleSpan;
 
                 // compute sample points
                 double[][][] y = null;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/SparseGradient.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/SparseGradient.java
index 7e71c6d..7f7714a 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/SparseGradient.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/SparseGradient.java
@@ -26,7 +26,7 @@
 import org.apache.commons.math4.legacy.core.Field;
 import org.apache.commons.math4.legacy.core.FieldElement;
 import org.apache.commons.math4.legacy.core.RealFieldElement;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * First derivative computation with large number of variables.
@@ -328,7 +328,7 @@
     /** {@inheritDoc} */
     @Override
     public SparseGradient remainder(final double a) {
-        return new SparseGradient(AccurateMath.IEEEremainder(value, a), derivatives);
+        return new SparseGradient(JdkMath.IEEEremainder(value, a), derivatives);
     }
 
     /** {@inheritDoc} */
@@ -336,8 +336,8 @@
     public SparseGradient remainder(final SparseGradient a) {
 
         // compute k such that lhs % rhs = lhs - k rhs
-        final double rem = AccurateMath.IEEEremainder(value, a.value);
-        final double k   = AccurateMath.rint((value - rem) / a.value);
+        final double rem = JdkMath.IEEEremainder(value, a.value);
+        final double k   = JdkMath.rint((value - rem) / a.value);
 
         return subtract(a.multiply(k));
 
@@ -357,31 +357,31 @@
     /** {@inheritDoc} */
     @Override
     public SparseGradient ceil() {
-        return createConstant(AccurateMath.ceil(value));
+        return createConstant(JdkMath.ceil(value));
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient floor() {
-        return createConstant(AccurateMath.floor(value));
+        return createConstant(JdkMath.floor(value));
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient rint() {
-        return createConstant(AccurateMath.rint(value));
+        return createConstant(JdkMath.rint(value));
     }
 
     /** {@inheritDoc} */
     @Override
     public long round() {
-        return AccurateMath.round(value);
+        return JdkMath.round(value);
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient signum() {
-        return createConstant(AccurateMath.signum(value));
+        return createConstant(JdkMath.signum(value));
     }
 
     /** {@inheritDoc} */
@@ -409,9 +409,9 @@
     /** {@inheritDoc} */
     @Override
     public SparseGradient scalb(final int n) {
-        final SparseGradient out = new SparseGradient(AccurateMath.scalb(value, n), Collections.<Integer, Double>emptyMap());
+        final SparseGradient out = new SparseGradient(JdkMath.scalb(value, n), Collections.<Integer, Double>emptyMap());
         for (Map.Entry<Integer, Double> entry : derivatives.entrySet()) {
-            out.derivatives.put(entry.getKey(), AccurateMath.scalb(entry.getValue(), n));
+            out.derivatives.put(entry.getKey(), JdkMath.scalb(entry.getValue(), n));
         }
         return out;
     }
@@ -425,8 +425,8 @@
             return createConstant(Double.NaN);
         } else {
 
-            final int expX = AccurateMath.getExponent(value);
-            final int expY = AccurateMath.getExponent(y.value);
+            final int expX = JdkMath.getExponent(value);
+            final int expY = JdkMath.getExponent(y.value);
             if (expX > expY + 27) {
                 // y is negligible with respect to x
                 return abs();
@@ -481,14 +481,14 @@
     /** {@inheritDoc} */
     @Override
     public SparseGradient sqrt() {
-        final double sqrt = AccurateMath.sqrt(value);
+        final double sqrt = JdkMath.sqrt(value);
         return new SparseGradient(sqrt, 0.5 / sqrt, derivatives);
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient cbrt() {
-        final double cbrt = AccurateMath.cbrt(value);
+        final double cbrt = JdkMath.cbrt(value);
         return new SparseGradient(cbrt, 1.0 / (3 * cbrt * cbrt), derivatives);
     }
 
@@ -500,15 +500,15 @@
         } else if (n == 3) {
             return cbrt();
         } else {
-            final double root = AccurateMath.pow(value, 1.0 / n);
-            return new SparseGradient(root, 1.0 / (n * AccurateMath.pow(root, n - 1)), derivatives);
+            final double root = JdkMath.pow(value, 1.0 / n);
+            return new SparseGradient(root, 1.0 / (n * JdkMath.pow(root, n - 1)), derivatives);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient pow(final double p) {
-        return new SparseGradient(AccurateMath.pow(value,  p), p * AccurateMath.pow(value,  p - 1), derivatives);
+        return new SparseGradient(JdkMath.pow(value,  p), p * JdkMath.pow(value,  p - 1), derivatives);
     }
 
     /** {@inheritDoc} */
@@ -517,7 +517,7 @@
         if (n == 0) {
             return getField().getOne();
         } else {
-            final double valueNm1 = AccurateMath.pow(value,  n - 1);
+            final double valueNm1 = JdkMath.pow(value,  n - 1);
             return new SparseGradient(value * valueNm1, n * valueNm1, derivatives);
         }
     }
@@ -543,28 +543,28 @@
                 return x.getField().getZero();
             }
         } else {
-            final double ax = AccurateMath.pow(a, x.value);
-            return new SparseGradient(ax, ax * AccurateMath.log(a), x.derivatives);
+            final double ax = JdkMath.pow(a, x.value);
+            return new SparseGradient(ax, ax * JdkMath.log(a), x.derivatives);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient exp() {
-        final double e = AccurateMath.exp(value);
+        final double e = JdkMath.exp(value);
         return new SparseGradient(e, e, derivatives);
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient expm1() {
-        return new SparseGradient(AccurateMath.expm1(value), AccurateMath.exp(value), derivatives);
+        return new SparseGradient(JdkMath.expm1(value), JdkMath.exp(value), derivatives);
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient log() {
-        return new SparseGradient(AccurateMath.log(value), 1.0 / value, derivatives);
+        return new SparseGradient(JdkMath.log(value), 1.0 / value, derivatives);
     }
 
     /** Base 10 logarithm.
@@ -572,50 +572,50 @@
      */
     @Override
     public SparseGradient log10() {
-        return new SparseGradient(AccurateMath.log10(value), 1.0 / (AccurateMath.log(10.0) * value), derivatives);
+        return new SparseGradient(JdkMath.log10(value), 1.0 / (JdkMath.log(10.0) * value), derivatives);
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient log1p() {
-        return new SparseGradient(AccurateMath.log1p(value), 1.0 / (1.0 + value), derivatives);
+        return new SparseGradient(JdkMath.log1p(value), 1.0 / (1.0 + value), derivatives);
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient cos() {
-        return new SparseGradient(AccurateMath.cos(value), -AccurateMath.sin(value), derivatives);
+        return new SparseGradient(JdkMath.cos(value), -JdkMath.sin(value), derivatives);
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient sin() {
-        return new SparseGradient(AccurateMath.sin(value), AccurateMath.cos(value), derivatives);
+        return new SparseGradient(JdkMath.sin(value), JdkMath.cos(value), derivatives);
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient tan() {
-        final double t = AccurateMath.tan(value);
+        final double t = JdkMath.tan(value);
         return new SparseGradient(t, 1 + t * t, derivatives);
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient acos() {
-        return new SparseGradient(AccurateMath.acos(value), -1.0 / AccurateMath.sqrt(1 - value * value), derivatives);
+        return new SparseGradient(JdkMath.acos(value), -1.0 / JdkMath.sqrt(1 - value * value), derivatives);
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient asin() {
-        return new SparseGradient(AccurateMath.asin(value), 1.0 / AccurateMath.sqrt(1 - value * value), derivatives);
+        return new SparseGradient(JdkMath.asin(value), 1.0 / JdkMath.sqrt(1 - value * value), derivatives);
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient atan() {
-        return new SparseGradient(AccurateMath.atan(value), 1.0 / (1 + value * value), derivatives);
+        return new SparseGradient(JdkMath.atan(value), 1.0 / (1 + value * value), derivatives);
     }
 
     /** {@inheritDoc} */
@@ -635,12 +635,12 @@
 
             // compute atan2(y, x) = +/- pi - 2 atan(y / (r - x))
             final SparseGradient tmp = divide(r.subtract(x)).atan().multiply(-2);
-            a = tmp.add(tmp.value <= 0 ? -AccurateMath.PI : AccurateMath.PI);
+            a = tmp.add(tmp.value <= 0 ? -JdkMath.PI : JdkMath.PI);
 
         }
 
         // fix value to take special cases (+0/+0, +0/-0, -0/+0, -0/-0, +/-infinity) correctly
-        a.value = AccurateMath.atan2(value, x.value);
+        a.value = JdkMath.atan2(value, x.value);
 
         return a;
 
@@ -658,52 +658,52 @@
     /** {@inheritDoc} */
     @Override
     public SparseGradient cosh() {
-        return new SparseGradient(AccurateMath.cosh(value), AccurateMath.sinh(value), derivatives);
+        return new SparseGradient(JdkMath.cosh(value), JdkMath.sinh(value), derivatives);
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient sinh() {
-        return new SparseGradient(AccurateMath.sinh(value), AccurateMath.cosh(value), derivatives);
+        return new SparseGradient(JdkMath.sinh(value), JdkMath.cosh(value), derivatives);
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient tanh() {
-        final double t = AccurateMath.tanh(value);
+        final double t = JdkMath.tanh(value);
         return new SparseGradient(t, 1 - t * t, derivatives);
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient acosh() {
-        return new SparseGradient(AccurateMath.acosh(value), 1.0 / AccurateMath.sqrt(value * value - 1.0), derivatives);
+        return new SparseGradient(JdkMath.acosh(value), 1.0 / JdkMath.sqrt(value * value - 1.0), derivatives);
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient asinh() {
-        return new SparseGradient(AccurateMath.asinh(value), 1.0 / AccurateMath.sqrt(value * value + 1.0), derivatives);
+        return new SparseGradient(JdkMath.asinh(value), 1.0 / JdkMath.sqrt(value * value + 1.0), derivatives);
     }
 
     /** {@inheritDoc} */
     @Override
     public SparseGradient atanh() {
-        return new SparseGradient(AccurateMath.atanh(value), 1.0 / (1.0 - value * value), derivatives);
+        return new SparseGradient(JdkMath.atanh(value), 1.0 / (1.0 - value * value), derivatives);
     }
 
     /** Convert radians to degrees, with error of less than 0.5 ULP.
      *  @return instance converted into degrees
      */
     public SparseGradient toDegrees() {
-        return new SparseGradient(AccurateMath.toDegrees(value), AccurateMath.toDegrees(1.0), derivatives);
+        return new SparseGradient(JdkMath.toDegrees(value), JdkMath.toDegrees(1.0), derivatives);
     }
 
     /** Convert degrees to radians, with error of less than 0.5 ULP.
      *  @return instance converted into radians
      */
     public SparseGradient toRadians() {
-        return new SparseGradient(AccurateMath.toRadians(value), AccurateMath.toRadians(1.0), derivatives);
+        return new SparseGradient(JdkMath.toRadians(value), JdkMath.toRadians(1.0), derivatives);
     }
 
     /** Evaluate Taylor expansion of a sparse gradient.
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Abs.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Abs.java
index 668a886..e959591 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Abs.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Abs.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.analysis.function;
 
 import org.apache.commons.math4.legacy.analysis.UnivariateFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Absolute value function.
@@ -29,6 +29,6 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.abs(x);
+        return JdkMath.abs(x);
     }
 }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Acos.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Acos.java
index fcfde56..b630938 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Acos.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Acos.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Arc-cosine function.
@@ -30,7 +30,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.acos(x);
+        return JdkMath.acos(x);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Acosh.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Acosh.java
index 3f85696..8ace23c 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Acosh.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Acosh.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Hyperbolic arc-cosine function.
@@ -30,7 +30,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.acosh(x);
+        return JdkMath.acosh(x);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Asin.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Asin.java
index fc94591..8a8a565 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Asin.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Asin.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Arc-sine function.
@@ -30,7 +30,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.asin(x);
+        return JdkMath.asin(x);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Asinh.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Asinh.java
index 98e38ce..0da7c05 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Asinh.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Asinh.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Hyperbolic arc-sine function.
@@ -30,7 +30,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.asinh(x);
+        return JdkMath.asinh(x);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Atan.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Atan.java
index c52d686..99d5085 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Atan.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Atan.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Arc-tangent function.
@@ -30,7 +30,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.atan(x);
+        return JdkMath.atan(x);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Atan2.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Atan2.java
index 927787b..e7ae65f 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Atan2.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Atan2.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.analysis.function;
 
 import org.apache.commons.math4.legacy.analysis.BivariateFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Arc-tangent function.
@@ -29,6 +29,6 @@
     /** {@inheritDoc} */
     @Override
     public double value(double y, double x) {
-        return AccurateMath.atan2(y, x);
+        return JdkMath.atan2(y, x);
     }
 }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Atanh.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Atanh.java
index 6061dd1..588599f 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Atanh.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Atanh.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Hyperbolic arc-tangent function.
@@ -30,7 +30,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.atanh(x);
+        return JdkMath.atanh(x);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Cbrt.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Cbrt.java
index ed97844..26f7225 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Cbrt.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Cbrt.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Cube root function.
@@ -30,7 +30,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.cbrt(x);
+        return JdkMath.cbrt(x);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Ceil.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Ceil.java
index 5ec6b36..7cbec78 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Ceil.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Ceil.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.analysis.function;
 
 import org.apache.commons.math4.legacy.analysis.UnivariateFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * {@code ceil} function.
@@ -29,6 +29,6 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.ceil(x);
+        return JdkMath.ceil(x);
     }
 }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Cos.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Cos.java
index c82e237..7751f5c 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Cos.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Cos.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Cosine function.
@@ -30,7 +30,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.cos(x);
+        return JdkMath.cos(x);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Cosh.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Cosh.java
index 32aa17e..f172f37 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Cosh.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Cosh.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Hyperbolic cosine function.
@@ -30,7 +30,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.cosh(x);
+        return JdkMath.cosh(x);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Exp.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Exp.java
index bc8530e..49192a8 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Exp.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Exp.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Exponential function.
@@ -30,7 +30,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.exp(x);
+        return JdkMath.exp(x);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Expm1.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Expm1.java
index 1d683e2..767e4b2 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Expm1.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Expm1.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * <code>e<sup>x</sup>-1</code> function.
@@ -30,7 +30,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.expm1(x);
+        return JdkMath.expm1(x);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Floor.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Floor.java
index 26267ce..8ceccf3 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Floor.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Floor.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.analysis.function;
 
 import org.apache.commons.math4.legacy.analysis.UnivariateFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * {@code floor} function.
@@ -29,6 +29,6 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.floor(x);
+        return JdkMath.floor(x);
     }
 }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Gaussian.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Gaussian.java
index 92f3fbc..0ac316a 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Gaussian.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Gaussian.java
@@ -25,7 +25,7 @@
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
 import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.numbers.core.Precision;
 
 /**
@@ -76,7 +76,7 @@
     public Gaussian(double mean,
                     double sigma)
         throws NotStrictlyPositiveException {
-        this(1 / (sigma * AccurateMath.sqrt(2 * Math.PI)), mean, sigma);
+        this(1 / (sigma * JdkMath.sqrt(2 * Math.PI)), mean, sigma);
     }
 
     /**
@@ -194,7 +194,7 @@
     private static double value(double xMinusMean,
                                 double norm,
                                 double i2s2) {
-        return norm * AccurateMath.exp(-xMinusMean * xMinusMean * i2s2);
+        return norm * JdkMath.exp(-xMinusMean * xMinusMean * i2s2);
     }
 
     /** {@inheritDoc}
@@ -217,7 +217,7 @@
         final double[] p = new double[f.length];
         p[0] = 1;
         final double u2 = u * u;
-        double coeff = norm * AccurateMath.exp(-0.5 * u2);
+        double coeff = norm * JdkMath.exp(-0.5 * u2);
         if (coeff <= Precision.SAFE_MIN) {
             Arrays.fill(f, 0.0);
         } else {
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/HarmonicOscillator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/HarmonicOscillator.java
index b0c03e3..e3df48d 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/HarmonicOscillator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/HarmonicOscillator.java
@@ -22,7 +22,7 @@
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * <a href="http://en.wikipedia.org/wiki/Harmonic_oscillator">
@@ -112,7 +112,7 @@
 
             final double xTimesOmegaPlusPhase = omega * x + phase;
             final double a = HarmonicOscillator.value(xTimesOmegaPlusPhase, 1);
-            final double p = -amplitude * AccurateMath.sin(xTimesOmegaPlusPhase);
+            final double p = -amplitude * JdkMath.sin(xTimesOmegaPlusPhase);
             final double w = p * x;
 
             return new double[] { a, w, p };
@@ -147,7 +147,7 @@
      */
     private static double value(double xTimesOmegaPlusPhase,
                                 double amplitude) {
-        return amplitude * AccurateMath.cos(xTimesOmegaPlusPhase);
+        return amplitude * JdkMath.cos(xTimesOmegaPlusPhase);
     }
 
     /** {@inheritDoc}
@@ -160,9 +160,9 @@
         double[] f = new double[t.getOrder() + 1];
 
         final double alpha = omega * x + phase;
-        f[0] = amplitude * AccurateMath.cos(alpha);
+        f[0] = amplitude * JdkMath.cos(alpha);
         if (f.length > 1) {
-            f[1] = -amplitude * omega * AccurateMath.sin(alpha);
+            f[1] = -amplitude * omega * JdkMath.sin(alpha);
             final double mo2 = - omega * omega;
             for (int i = 2; i < f.length; ++i) {
                 f[i] = mo2 * f[i - 2];
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Log.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Log.java
index 6dfdb21..99bf7ed 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Log.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Log.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Natural logarithm function.
@@ -30,7 +30,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.log(x);
+        return JdkMath.log(x);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Log10.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Log10.java
index e7228a3..57ba788 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Log10.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Log10.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Base 10 logarithm function.
@@ -31,7 +31,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.log10(x);
+        return JdkMath.log10(x);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Log1p.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Log1p.java
index 1f24404..474a4c7 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Log1p.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Log1p.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * <code>log(1 + p)</code> function.
@@ -30,7 +30,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.log1p(x);
+        return JdkMath.log1p(x);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Logistic.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Logistic.java
index 9dc43c9..3c38b71 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Logistic.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Logistic.java
@@ -23,7 +23,7 @@
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
 import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * <a href="http://en.wikipedia.org/wiki/Generalised_logistic_function">
@@ -147,10 +147,10 @@
 
             final double mMinusX = param[1] - x;
             final double oneOverN = 1 / param[5];
-            final double exp = AccurateMath.exp(b * mMinusX);
+            final double exp = JdkMath.exp(b * mMinusX);
             final double qExp = q * exp;
             final double qExp1 = qExp + 1;
-            final double factor1 = (param[0] - param[4]) * oneOverN / AccurateMath.pow(qExp1, oneOverN);
+            final double factor1 = (param[0] - param[4]) * oneOverN / JdkMath.pow(qExp1, oneOverN);
             final double factor2 = -factor1 / qExp1;
 
             // Components of the gradient.
@@ -159,7 +159,7 @@
             final double gb = factor2 * mMinusX * qExp;
             final double gq = factor2 * exp;
             final double ga = Logistic.value(mMinusX, 0, b, q, 1, oneOverN);
-            final double gn = factor1 * AccurateMath.log(qExp1) * oneOverN;
+            final double gn = factor1 * JdkMath.log(qExp1) * oneOverN;
 
             return new double[] { gk, gm, gb, gq, ga, gn };
         }
@@ -207,7 +207,7 @@
                                 double q,
                                 double a,
                                 double oneOverN) {
-        return a + (k - a) / AccurateMath.pow(1 + q * AccurateMath.exp(b * mMinusX), oneOverN);
+        return a + (k - a) / JdkMath.pow(1 + q * JdkMath.exp(b * mMinusX), oneOverN);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Logit.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Logit.java
index 0da8537..9b9ce73 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Logit.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Logit.java
@@ -23,7 +23,7 @@
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * <a href="http://en.wikipedia.org/wiki/Logit">
@@ -153,7 +153,7 @@
         if (x < lo || x > hi) {
             throw new OutOfRangeException(x, lo, hi);
         }
-        return AccurateMath.log((x - lo) / (hi - x));
+        return JdkMath.log((x - lo) / (hi - x));
     }
 
     /** {@inheritDoc}
@@ -170,7 +170,7 @@
         double[] f = new double[t.getOrder() + 1];
 
         // function value
-        f[0] = AccurateMath.log((x - lo) / (hi - x));
+        f[0] = JdkMath.log((x - lo) / (hi - x));
 
         if (Double.isInfinite(f[0])) {
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Max.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Max.java
index f338b813..b672e1a 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Max.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Max.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.analysis.function;
 
 import org.apache.commons.math4.legacy.analysis.BivariateFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Maximum function.
@@ -29,6 +29,6 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x, double y) {
-        return AccurateMath.max(x, y);
+        return JdkMath.max(x, y);
     }
 }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Min.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Min.java
index 90eba84..f5399f1 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Min.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Min.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.analysis.function;
 
 import org.apache.commons.math4.legacy.analysis.BivariateFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Minimum function.
@@ -29,6 +29,6 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x, double y) {
-        return AccurateMath.min(x, y);
+        return JdkMath.min(x, y);
     }
 }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Pow.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Pow.java
index 70b6915..c008095 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Pow.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Pow.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.analysis.function;
 
 import org.apache.commons.math4.legacy.analysis.BivariateFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Power function.
@@ -29,6 +29,6 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x, double y) {
-        return AccurateMath.pow(x, y);
+        return JdkMath.pow(x, y);
     }
 }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Power.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Power.java
index 91cfc58..2342d15 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Power.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Power.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Power function.
@@ -40,7 +40,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.pow(x, p);
+        return JdkMath.pow(x, p);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Rint.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Rint.java
index 7b81161..686078a 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Rint.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Rint.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.analysis.function;
 
 import org.apache.commons.math4.legacy.analysis.UnivariateFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * {@code rint} function.
@@ -29,6 +29,6 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.rint(x);
+        return JdkMath.rint(x);
     }
 }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sigmoid.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sigmoid.java
index 2f1dfe5..46eb585 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sigmoid.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sigmoid.java
@@ -24,7 +24,7 @@
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * <a href="http://en.wikipedia.org/wiki/Sigmoid_function">
@@ -114,7 +114,7 @@
                    DimensionMismatchException {
             validateParameters(param);
 
-            final double invExp1 = 1 / (1 + AccurateMath.exp(-x));
+            final double invExp1 = 1 / (1 + JdkMath.exp(-x));
 
             return new double[] { 1 - invExp1, invExp1 };
         }
@@ -150,7 +150,7 @@
     private static double value(double x,
                                 double lo,
                                 double hi) {
-        return lo + (hi - lo) / (1 + AccurateMath.exp(-x));
+        return lo + (hi - lo) / (1 + JdkMath.exp(-x));
     }
 
     /** {@inheritDoc}
@@ -161,7 +161,7 @@
         throws DimensionMismatchException {
 
         double[] f = new double[t.getOrder() + 1];
-        final double exp = AccurateMath.exp(-t.getValue());
+        final double exp = JdkMath.exp(-t.getValue());
         if (Double.isInfinite(exp)) {
 
             // special handling near lower boundary, to avoid NaN
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Signum.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Signum.java
index 067eac3..ddc1322 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Signum.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Signum.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.analysis.function;
 
 import org.apache.commons.math4.legacy.analysis.UnivariateFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * {@code signum} function.
@@ -29,6 +29,6 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.signum(x);
+        return JdkMath.signum(x);
     }
 }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sin.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sin.java
index 81aaedd..c5b82c9 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sin.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sin.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Sine function.
@@ -30,7 +30,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.sin(x);
+        return JdkMath.sin(x);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sinc.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sinc.java
index a33e0da..1de98df 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sinc.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sinc.java
@@ -20,7 +20,7 @@
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * <a href="http://en.wikipedia.org/wiki/Sinc_function">Sinc</a> function,
@@ -81,14 +81,14 @@
     /** {@inheritDoc} */
     @Override
     public double value(final double x) {
-        final double scaledX = normalized ? AccurateMath.PI * x : x;
-        if (AccurateMath.abs(scaledX) <= SHORTCUT) {
+        final double scaledX = normalized ? JdkMath.PI * x : x;
+        if (JdkMath.abs(scaledX) <= SHORTCUT) {
             // use Taylor series
             final double scaledX2 = scaledX * scaledX;
             return ((scaledX2 - 20) * scaledX2 + 120) / 120;
         } else {
             // use definition expression
-            return AccurateMath.sin(scaledX) / scaledX;
+            return JdkMath.sin(scaledX) / scaledX;
         }
     }
 
@@ -99,12 +99,12 @@
     public DerivativeStructure value(final DerivativeStructure t)
         throws DimensionMismatchException {
 
-        final double scaledX  = (normalized ? AccurateMath.PI : 1) * t.getValue();
+        final double scaledX  = (normalized ? JdkMath.PI : 1) * t.getValue();
         final double scaledX2 = scaledX * scaledX;
 
         double[] f = new double[t.getOrder() + 1];
 
-        if (AccurateMath.abs(scaledX) <= SHORTCUT) {
+        if (JdkMath.abs(scaledX) <= SHORTCUT) {
 
             for (int i = 0; i < f.length; ++i) {
                 final int k = i / 2;
@@ -122,8 +122,8 @@
         } else {
 
             final double inv = 1 / scaledX;
-            final double cos = AccurateMath.cos(scaledX);
-            final double sin = AccurateMath.sin(scaledX);
+            final double cos = JdkMath.cos(scaledX);
+            final double sin = JdkMath.sin(scaledX);
 
             f[0] = inv * sin;
 
@@ -182,10 +182,10 @@
         }
 
         if (normalized) {
-            double scale = AccurateMath.PI;
+            double scale = JdkMath.PI;
             for (int i = 1; i < f.length; ++i) {
                 f[i]  *= scale;
-                scale *= AccurateMath.PI;
+                scale *= JdkMath.PI;
             }
         }
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sinh.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sinh.java
index 4a9a515..3c6f851 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sinh.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sinh.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Hyperbolic sine function.
@@ -30,7 +30,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.sinh(x);
+        return JdkMath.sinh(x);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sqrt.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sqrt.java
index f8146aa..35ec90e 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sqrt.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Sqrt.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Square-root function.
@@ -30,7 +30,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.sqrt(x);
+        return JdkMath.sqrt(x);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Tan.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Tan.java
index 5fa6f4f..626bd14 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Tan.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Tan.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Tangent function.
@@ -30,7 +30,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.tan(x);
+        return JdkMath.tan(x);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Tanh.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Tanh.java
index 26f8016..d539d44 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Tanh.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Tanh.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Hyperbolic tangent function.
@@ -30,7 +30,7 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.tanh(x);
+        return JdkMath.tanh(x);
     }
 
     /** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Ulp.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Ulp.java
index 8400240..9ff52ad 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Ulp.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/Ulp.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.analysis.function;
 
 import org.apache.commons.math4.legacy.analysis.UnivariateFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * {@code ulp} function.
@@ -29,6 +29,6 @@
     /** {@inheritDoc} */
     @Override
     public double value(double x) {
-        return AccurateMath.ulp(x);
+        return JdkMath.ulp(x);
     }
 }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/IterativeLegendreGaussIntegrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/IterativeLegendreGaussIntegrator.java
index e9011bc..51ee8ac 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/IterativeLegendreGaussIntegrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/IterativeLegendreGaussIntegrator.java
@@ -22,7 +22,7 @@
 import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
 import org.apache.commons.math4.legacy.exception.TooManyEvaluationsException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * This algorithm divides the integration interval into equally-sized
@@ -122,10 +122,10 @@
             final double t = stage(n);
 
             // Estimate the error.
-            final double delta = AccurateMath.abs(t - oldt);
+            final double delta = JdkMath.abs(t - oldt);
             final double limit =
-                AccurateMath.max(getAbsoluteAccuracy(),
-                             getRelativeAccuracy() * (AccurateMath.abs(oldt) + AccurateMath.abs(t)) * 0.5);
+                JdkMath.max(getAbsoluteAccuracy(),
+                             getRelativeAccuracy() * (JdkMath.abs(oldt) + JdkMath.abs(t)) * 0.5);
 
             // check convergence
             if (iterations.getCount() + 1 >= getMinimalIterationCount() &&
@@ -134,8 +134,8 @@
             }
 
             // Prepare next iteration.
-            final double ratio = AccurateMath.min(4, AccurateMath.pow(delta / limit, 0.5 / numberOfPoints));
-            n = AccurateMath.max((int) (ratio * n), n + 1);
+            final double ratio = JdkMath.min(4, JdkMath.pow(delta / limit, 0.5 / numberOfPoints));
+            n = JdkMath.max((int) (ratio * n), n + 1);
             oldt = t;
             iterations.increment();
         }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/MidPointIntegrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/MidPointIntegrator.java
index 3066851..00f255b 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/MidPointIntegrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/MidPointIntegrator.java
@@ -17,7 +17,7 @@
 package org.apache.commons.math4.legacy.analysis.integration;
 
 import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Implements the <a href="https://en.wikipedia.org/wiki/Riemann_sum#Midpoint_rule">
@@ -113,7 +113,7 @@
                          double diffMaxMin) {
         // number of points in the previous stage. This stage will contribute
         // 2*3^{n-1} more points.
-        final long np = (long) AccurateMath.pow(3, n - 1);
+        final long np = (long) JdkMath.pow(3, n - 1);
         double sum = 0;
 
         // spacing between adjacent new points
@@ -151,9 +151,9 @@
             final int i = iterations.getCount();
             final double t = stage(i, oldt, min, diff);
             if (i >= getMinimalIterationCount()) {
-                final double delta = AccurateMath.abs(t - oldt);
+                final double delta = JdkMath.abs(t - oldt);
                 final double rLimit =
-                        getRelativeAccuracy() * (AccurateMath.abs(oldt) + AccurateMath.abs(t)) * 0.5;
+                        getRelativeAccuracy() * (JdkMath.abs(oldt) + JdkMath.abs(t)) * 0.5;
                 if ((delta <= rLimit) || (delta <= getAbsoluteAccuracy())) {
                     return t;
                 }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/RombergIntegrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/RombergIntegrator.java
index 8ce1d90..4ee7c18 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/RombergIntegrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/RombergIntegrator.java
@@ -17,7 +17,7 @@
 package org.apache.commons.math4.legacy.analysis.integration;
 
 import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Implements the <a href="http://mathworld.wolfram.com/RombergIntegration.html">
@@ -120,8 +120,8 @@
             }
             final double s = currentRow[i];
             if (i >= getMinimalIterationCount()) {
-                final double delta  = AccurateMath.abs(s - olds);
-                final double rLimit = getRelativeAccuracy() * (AccurateMath.abs(olds) + AccurateMath.abs(s)) * 0.5;
+                final double delta  = JdkMath.abs(s - olds);
+                final double rLimit = getRelativeAccuracy() * (JdkMath.abs(olds) + JdkMath.abs(s)) * 0.5;
                 if ((delta <= rLimit) || (delta <= getAbsoluteAccuracy())) {
                     return s;
                 }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/SimpsonIntegrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/SimpsonIntegrator.java
index 2ce475b..df1fe72 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/SimpsonIntegrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/SimpsonIntegrator.java
@@ -17,7 +17,7 @@
 package org.apache.commons.math4.legacy.analysis.integration;
 
 import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Implements <a href="http://mathworld.wolfram.com/SimpsonsRule.html">
@@ -113,8 +113,8 @@
             final double t = qtrap.stage(this, i + 1); // 1-stage ahead of the iteration
             final double s = (4 * t - oldt) / 3.0;
             if (i >= getMinimalIterationCount()) {
-                final double delta = AccurateMath.abs(s - olds);
-                final double rLimit = getRelativeAccuracy() * (AccurateMath.abs(olds) + AccurateMath.abs(s)) * 0.5;
+                final double delta = JdkMath.abs(s - olds);
+                final double rLimit = getRelativeAccuracy() * (JdkMath.abs(olds) + JdkMath.abs(s)) * 0.5;
                 if (delta <= rLimit ||
                     delta <= getAbsoluteAccuracy()) {
                     return s;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/TrapezoidIntegrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/TrapezoidIntegrator.java
index f009df0..1fea13a 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/TrapezoidIntegrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/TrapezoidIntegrator.java
@@ -17,7 +17,7 @@
 package org.apache.commons.math4.legacy.analysis.integration;
 
 import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Implements the <a href="http://mathworld.wolfram.com/TrapezoidalRule.html">
@@ -146,9 +146,9 @@
             final int i = iterations.getCount();
             final double t = stage(this, i);
             if (i >= getMinimalIterationCount()) {
-                final double delta = AccurateMath.abs(t - oldt);
+                final double delta = JdkMath.abs(t - oldt);
                 final double rLimit =
-                    getRelativeAccuracy() * (AccurateMath.abs(oldt) + AccurateMath.abs(t)) * 0.5;
+                    getRelativeAccuracy() * (JdkMath.abs(oldt) + JdkMath.abs(t)) * 0.5;
                 if ((delta <= rLimit) || (delta <= getAbsoluteAccuracy())) {
                     return t;
                 }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/gauss/HermiteRuleFactory.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/gauss/HermiteRuleFactory.java
index 30cb26a..4cdbc0f 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/gauss/HermiteRuleFactory.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/gauss/HermiteRuleFactory.java
@@ -16,7 +16,7 @@
  */
 package org.apache.commons.math4.legacy.analysis.integration.gauss;
 
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.Pair;
 
 /**
@@ -74,8 +74,8 @@
         final Double[] points = new Double[numberOfPoints];
         final Double[] weights = new Double[numberOfPoints];
 
-        final double sqrtTwoTimesLastNumPoints = AccurateMath.sqrt(2.0 * lastNumPoints);
-        final double sqrtTwoTimesNumPoints = AccurateMath.sqrt(2.0 * numberOfPoints);
+        final double sqrtTwoTimesLastNumPoints = JdkMath.sqrt(2.0 * lastNumPoints);
+        final double sqrtTwoTimesNumPoints = JdkMath.sqrt(2.0 * numberOfPoints);
 
         // Find i-th root of H[n+1] by bracketing.
         final int iMax = numberOfPoints / 2;
@@ -96,8 +96,8 @@
             for (int j = 1; j < numberOfPoints; j++) {
                 // Compute H[j+1](a) and H[j+1](b)
                 final double jp1 = j + 1.0;
-                final double s = AccurateMath.sqrt(2 / jp1);
-                final double sm = AccurateMath.sqrt(j / jp1);
+                final double s = JdkMath.sqrt(2 / jp1);
+                final double sm = JdkMath.sqrt(j / jp1);
                 final double hpa = s * a * ha - sm * hma;
                 final double hpb = s * b * hb - sm * hmb;
                 hma = ha;
@@ -121,8 +121,8 @@
                 for (int j = 1; j < numberOfPoints; j++) {
                     // Compute H[j+1](c)
                     final double jp1 = j + 1.0;
-                    final double s = AccurateMath.sqrt(2 / jp1);
-                    final double sm = AccurateMath.sqrt(j / jp1);
+                    final double s = JdkMath.sqrt(2 / jp1);
+                    final double sm = JdkMath.sqrt(j / jp1);
                     final double hpc = s * c * hc - sm * hmc;
                     hmc = hc;
                     hc = hpc;
@@ -160,7 +160,7 @@
             double hm = H0;
             for (int j = 1; j < numberOfPoints; j += 2) {
                 final double jp1 = j + 1.0;
-                hm = -AccurateMath.sqrt(j / jp1) * hm;
+                hm = -JdkMath.sqrt(j / jp1) * hm;
             }
             final double d = sqrtTwoTimesNumPoints * hm;
             final double w = 2 / (d * d);
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/AkimaSplineInterpolator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/AkimaSplineInterpolator.java
index 2d1520d..740b5a0 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/AkimaSplineInterpolator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/AkimaSplineInterpolator.java
@@ -23,7 +23,7 @@
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 import org.apache.commons.numbers.core.Precision;
 
@@ -123,11 +123,11 @@
             for (int i = 1; i < weights.length; i++) {
                 final double a = differences[i];
                 final double b = differences[i - 1];
-                weights[i] = AccurateMath.abs(a - b) + 0.5 * AccurateMath.abs(a + b);
+                weights[i] = JdkMath.abs(a - b) + 0.5 * JdkMath.abs(a + b);
             }
         } else {
             for (int i = 1; i < weights.length; i++) {
-                weights[i] = AccurateMath.abs(differences[i] - differences[i - 1]);
+                weights[i] = JdkMath.abs(differences[i] - differences[i - 1]);
             }
         }
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/InterpolatingMicrosphere.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/InterpolatingMicrosphere.java
index 88f5c02..d4d4cd4 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/InterpolatingMicrosphere.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/InterpolatingMicrosphere.java
@@ -26,7 +26,7 @@
 import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
 import org.apache.commons.math4.legacy.exception.MaxCountExceededException;
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 
 /**
@@ -224,13 +224,13 @@
             final double[] diff = MathArrays.ebeSubtract(samplePoints[i], point);
             final double diffNorm = Norm.L2.of(diff);
 
-            if (AccurateMath.abs(diffNorm) < noInterpolationTolerance) {
+            if (JdkMath.abs(diffNorm) < noInterpolationTolerance) {
                 // No need to interpolate, as the interpolation point is
                 // actually (very close to) one of the sampled points.
                 return sampleValues[i];
             }
 
-            final double weight = AccurateMath.pow(diffNorm, -exponent);
+            final double weight = JdkMath.pow(diffNorm, -exponent);
             illuminate(diff, sampleValues[i], weight);
         }
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/InterpolatingMicrosphere2D.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/InterpolatingMicrosphere2D.java
index eaca3ca..b92e7b2 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/InterpolatingMicrosphere2D.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/InterpolatingMicrosphere2D.java
@@ -16,7 +16,7 @@
  */
 package org.apache.commons.math4.legacy.analysis.interpolation;
 
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Utility class for the {@link MicrosphereProjectionInterpolator} algorithm.
@@ -60,8 +60,8 @@
         for (int i = 0; i < size; i++) {
             final double angle = i * twopi / size;
 
-            add(new double[] { AccurateMath.cos(angle),
-                               AccurateMath.sin(angle) },
+            add(new double[] { JdkMath.cos(angle),
+                               JdkMath.sin(angle) },
                 false);
         }
     }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/LoessInterpolator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/LoessInterpolator.java
index 63a94f7..933f5b2 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/LoessInterpolator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/LoessInterpolator.java
@@ -28,7 +28,7 @@
 import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 
 /**
@@ -296,7 +296,7 @@
                 double sumXSquared = 0;
                 double sumY = 0;
                 double sumXY = 0;
-                double denom = AccurateMath.abs(1.0 / (xval[edge] - x));
+                double denom = JdkMath.abs(1.0 / (xval[edge] - x));
                 for (int k = ileft; k <= iright; ++k) {
                     final double xk   = xval[k];
                     final double yk   = yval[k];
@@ -316,7 +316,7 @@
                 final double meanXSquared = sumXSquared / sumWeights;
 
                 final double beta;
-                if (AccurateMath.sqrt(AccurateMath.abs(meanXSquared - meanX * meanX)) < accuracy) {
+                if (JdkMath.sqrt(JdkMath.abs(meanXSquared - meanX * meanX)) < accuracy) {
                     beta = 0;
                 } else {
                     beta = (meanXY - meanX * meanY) / (meanXSquared - meanX * meanX);
@@ -325,7 +325,7 @@
                 final double alpha = meanY - beta * meanX;
 
                 res[i] = beta * x + alpha;
-                residuals[i] = AccurateMath.abs(yval[i] - res[i]);
+                residuals[i] = JdkMath.abs(yval[i] - res[i]);
             }
 
             // No need to recompute the robustness weights at the last
@@ -343,7 +343,7 @@
             Arrays.sort(sortedResiduals);
             final double medianResidual = sortedResiduals[n / 2];
 
-            if (AccurateMath.abs(medianResidual) < accuracy) {
+            if (JdkMath.abs(medianResidual) < accuracy) {
                 break;
             }
 
@@ -454,7 +454,7 @@
      * @return <code>(1 - |x|<sup>3</sup>)<sup>3</sup></code> for |x| &lt; 1, 0 otherwise.
      */
     private static double tricube(final double x) {
-        final double absX = AccurateMath.abs(x);
+        final double absX = JdkMath.abs(x);
         if (absX >= 1.0) {
             return 0.0;
         }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialFunction.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialFunction.java
index d9884c8..b85cffc 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialFunction.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialFunction.java
@@ -25,7 +25,7 @@
 import org.apache.commons.math4.legacy.exception.NoDataException;
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Immutable representation of a real polynomial function with real coefficients.
@@ -167,8 +167,8 @@
      */
     public PolynomialFunction add(final PolynomialFunction p) {
         // identify the lowest degree polynomial
-        final int lowLength  = AccurateMath.min(coefficients.length, p.coefficients.length);
-        final int highLength = AccurateMath.max(coefficients.length, p.coefficients.length);
+        final int lowLength  = JdkMath.min(coefficients.length, p.coefficients.length);
+        final int highLength = JdkMath.max(coefficients.length, p.coefficients.length);
 
         // build the coefficients array
         double[] newCoefficients = new double[highLength];
@@ -192,8 +192,8 @@
      */
     public PolynomialFunction subtract(final PolynomialFunction p) {
         // identify the lowest degree polynomial
-        int lowLength  = AccurateMath.min(coefficients.length, p.coefficients.length);
-        int highLength = AccurateMath.max(coefficients.length, p.coefficients.length);
+        int lowLength  = JdkMath.min(coefficients.length, p.coefficients.length);
+        int highLength = JdkMath.max(coefficients.length, p.coefficients.length);
 
         // build the coefficients array
         double[] newCoefficients = new double[highLength];
@@ -236,8 +236,8 @@
 
         for (int i = 0; i < newCoefficients.length; ++i) {
             newCoefficients[i] = 0.0;
-            for (int j = AccurateMath.max(0, i + 1 - p.coefficients.length);
-                 j < AccurateMath.min(coefficients.length, i + 1);
+            for (int j = JdkMath.max(0, i + 1 - p.coefficients.length);
+                 j < JdkMath.min(coefficients.length, i + 1);
                  ++j) {
                 newCoefficients[i] += coefficients[j] * p.coefficients[i-j];
             }
@@ -320,7 +320,7 @@
                     }
                 }
 
-                double absAi = AccurateMath.abs(coefficients[i]);
+                double absAi = JdkMath.abs(coefficients[i]);
                 if ((absAi - 1) != 0) {
                     s.append(toString(absAi));
                     s.append(' ');
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialFunctionLagrangeForm.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialFunctionLagrangeForm.java
index 14f94b7..689743a 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialFunctionLagrangeForm.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialFunctionLagrangeForm.java
@@ -22,7 +22,7 @@
 import org.apache.commons.math4.legacy.exception.NonMonotonicSequenceException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 
 /**
@@ -216,7 +216,7 @@
             c[i] = y[i];
             d[i] = y[i];
             // find out the abscissa closest to z
-            final double dist = AccurateMath.abs(z - x[i]);
+            final double dist = JdkMath.abs(z - x[i]);
             if (dist < minDist) {
                 nearest = i;
                 minDist = dist;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialsUtils.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialsUtils.java
index 9842a05..08ce03e 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialsUtils.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialsUtils.java
@@ -23,7 +23,7 @@
 
 import org.apache.commons.numbers.fraction.BigFraction;
 import org.apache.commons.numbers.combinatorics.BinomialCoefficient;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * A collection of static methods that operate on or return polynomials.
@@ -341,7 +341,7 @@
 
         // First polynomial coefficient.
         for (int i = 0; i < dp1; i++){
-            newCoefficients[0] += coefficients[i] * AccurateMath.pow(shift, i);
+            newCoefficients[0] += coefficients[i] * JdkMath.pow(shift, i);
         }
 
         // Superior order.
@@ -349,7 +349,7 @@
         for (int i = 0; i < d; i++) {
             for (int j = i; j < d; j++){
                 newCoefficients[i + 1] += coeff[j + 1][j - i] *
-                    coefficients[j + 1] * AccurateMath.pow(shift, j - i);
+                    coefficients[j + 1] * JdkMath.pow(shift, j - i);
             }
         }
 
@@ -370,7 +370,7 @@
         // case, the lock object is an immutable field that belongs to this
         // class.
         synchronized (coefficients) {
-            final int maxDegree = (int) AccurateMath.floor(AccurateMath.sqrt(2.0 * coefficients.size())) - 1;
+            final int maxDegree = (int) JdkMath.floor(JdkMath.sqrt(2.0 * coefficients.size())) - 1;
             if (degree > maxDegree) {
                 computeUpToDegree(degree, maxDegree, generator, coefficients);
             }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/BaseSecantSolver.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/BaseSecantSolver.java
index 8f952e1..ff1f753 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/BaseSecantSolver.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/BaseSecantSolver.java
@@ -20,7 +20,7 @@
 import org.apache.commons.math4.legacy.analysis.UnivariateFunction;
 import org.apache.commons.math4.legacy.exception.ConvergenceException;
 import org.apache.commons.math4.legacy.exception.MathInternalError;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Base class for all bracketing <em>Secant</em>-based methods for root-finding
@@ -210,7 +210,7 @@
             // If the function value of the last approximation is too small,
             // given the function value accuracy, then we can't get closer to
             // the root than we already are.
-            if (AccurateMath.abs(f1) <= ftol) {
+            if (JdkMath.abs(f1) <= ftol) {
                 switch (allowed) {
                 case ANY_SIDE:
                     return x1;
@@ -241,7 +241,7 @@
 
             // If the current interval is within the given accuracies, we
             // are satisfied with the current approximation.
-            if (AccurateMath.abs(x1 - x0) < AccurateMath.max(rtol * AccurateMath.abs(x1),
+            if (JdkMath.abs(x1 - x0) < JdkMath.max(rtol * JdkMath.abs(x1),
                                                      atol)) {
                 switch (allowed) {
                 case ANY_SIDE:
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/BisectionSolver.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/BisectionSolver.java
index ff0290c..b833b28 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/BisectionSolver.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/BisectionSolver.java
@@ -17,7 +17,7 @@
 package org.apache.commons.math4.legacy.analysis.solvers;
 
 import org.apache.commons.math4.legacy.exception.TooManyEvaluationsException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Implements the <a href="http://mathworld.wolfram.com/Bisection.html">
@@ -82,7 +82,7 @@
                 max = m;
             }
 
-            if (AccurateMath.abs(max - min) <= absoluteAccuracy) {
+            if (JdkMath.abs(max - min) <= absoluteAccuracy) {
                 m = UnivariateSolverUtils.midpoint(min, max);
                 return m;
             }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/BracketingNthOrderBrentSolver.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/BracketingNthOrderBrentSolver.java
index 4a41726..f314a6d 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/BracketingNthOrderBrentSolver.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/BracketingNthOrderBrentSolver.java
@@ -23,7 +23,7 @@
 import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
 import org.apache.commons.math4.legacy.exception.TooManyEvaluationsException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.numbers.core.Precision;
 
 /**
@@ -199,11 +199,11 @@
         // current tightest bracketing of the root
         double xA    = x[signChangeIndex - 1];
         double yA    = y[signChangeIndex - 1];
-        double absYA = AccurateMath.abs(yA);
+        double absYA = JdkMath.abs(yA);
         int agingA   = 0;
         double xB    = x[signChangeIndex];
         double yB    = y[signChangeIndex];
-        double absYB = AccurateMath.abs(yB);
+        double absYB = JdkMath.abs(yB);
         int agingB   = 0;
 
         // search loop
@@ -211,8 +211,8 @@
 
             // check convergence of bracketing interval
             final double xTol = getAbsoluteAccuracy() +
-                                getRelativeAccuracy() * AccurateMath.max(AccurateMath.abs(xA), AccurateMath.abs(xB));
-            if (((xB - xA) <= xTol) || (AccurateMath.max(absYA, absYB) < getFunctionValueAccuracy())) {
+                                getRelativeAccuracy() * JdkMath.max(JdkMath.abs(xA), JdkMath.abs(xB));
+            if (((xB - xA) <= xTol) || (JdkMath.max(absYA, absYB) < getFunctionValueAccuracy())) {
                 switch (allowed) {
                 case ANY_SIDE :
                     return absYA < absYB ? xA : xB;
@@ -332,14 +332,14 @@
                 // the sign change occurs before the inserted point
                 xB = nextX;
                 yB = nextY;
-                absYB = AccurateMath.abs(yB);
+                absYB = JdkMath.abs(yB);
                 ++agingA;
                 agingB = 0;
             } else {
                 // the sign change occurs after the inserted point
                 xA = nextX;
                 yA = nextY;
-                absYA = AccurateMath.abs(yA);
+                absYA = JdkMath.abs(yA);
                 agingA = 0;
                 ++agingB;
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/LaguerreSolver.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/LaguerreSolver.java
index cd20e75..902c83b 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/LaguerreSolver.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/LaguerreSolver.java
@@ -24,7 +24,7 @@
 import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
 import org.apache.commons.math4.legacy.exception.TooManyEvaluationsException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Implements the <a href="http://mathworld.wolfram.com/LaguerresMethod.html">
@@ -100,13 +100,13 @@
 
         // Return the initial guess if it is good enough.
         final double yInitial = computeObjectiveValue(initial);
-        if (AccurateMath.abs(yInitial) <= functionValueAccuracy) {
+        if (JdkMath.abs(yInitial) <= functionValueAccuracy) {
             return initial;
         }
 
         // Return the first endpoint if it is good enough.
         final double yMin = computeObjectiveValue(min);
-        if (AccurateMath.abs(yMin) <= functionValueAccuracy) {
+        if (JdkMath.abs(yMin) <= functionValueAccuracy) {
             return min;
         }
 
@@ -117,7 +117,7 @@
 
         // Return the second endpoint if it is good enough.
         final double yMax = computeObjectiveValue(max);
-        if (AccurateMath.abs(yMax) <= functionValueAccuracy) {
+        if (JdkMath.abs(yMax) <= functionValueAccuracy) {
             return max;
         }
 
@@ -241,8 +241,8 @@
          */
         public boolean isRoot(double min, double max, Complex z) {
             if (isSequence(min, z.getReal(), max)) {
-                double tolerance = AccurateMath.max(getRelativeAccuracy() * z.abs(), getAbsoluteAccuracy());
-                return (AccurateMath.abs(z.getImaginary()) <= tolerance) ||
+                double tolerance = JdkMath.max(getRelativeAccuracy() * z.abs(), getAbsoluteAccuracy());
+                return (JdkMath.abs(z.getImaginary()) <= tolerance) ||
                      (z.abs() <= getFunctionValueAccuracy());
             }
             return false;
@@ -347,7 +347,7 @@
                 d2v = d2v.multiply(Complex.ofCartesian(2.0, 0.0));
 
                 // Check for convergence.
-                final double tolerance = AccurateMath.max(relativeAccuracy * z.abs(),
+                final double tolerance = JdkMath.max(relativeAccuracy * z.abs(),
                                                       absoluteAccuracy);
                 if ((z.subtract(oldz)).abs() <= tolerance) {
                     return z;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/MullerSolver.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/MullerSolver.java
index ac262cc..f71cdc6 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/MullerSolver.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/MullerSolver.java
@@ -19,7 +19,7 @@
 import org.apache.commons.math4.legacy.exception.NoBracketingException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
 import org.apache.commons.math4.legacy.exception.TooManyEvaluationsException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * This class implements the <a href="http://mathworld.wolfram.com/MullersMethod.html">
@@ -94,15 +94,15 @@
 
         // check for zeros before verifying bracketing
         final double fMin = computeObjectiveValue(min);
-        if (AccurateMath.abs(fMin) < functionValueAccuracy) {
+        if (JdkMath.abs(fMin) < functionValueAccuracy) {
             return min;
         }
         final double fMax = computeObjectiveValue(max);
-        if (AccurateMath.abs(fMax) < functionValueAccuracy) {
+        if (JdkMath.abs(fMax) < functionValueAccuracy) {
             return max;
         }
         final double fInitial = computeObjectiveValue(initial);
-        if (AccurateMath.abs(fInitial) <  functionValueAccuracy) {
+        if (JdkMath.abs(fInitial) <  functionValueAccuracy) {
             return initial;
         }
 
@@ -156,17 +156,17 @@
             final double d012 = (d12 - d01) / (x2 - x0);
             final double c1 = d01 + (x1 - x0) * d012;
             final double delta = c1 * c1 - 4 * y1 * d012;
-            final double xplus = x1 + (-2.0 * y1) / (c1 + AccurateMath.sqrt(delta));
-            final double xminus = x1 + (-2.0 * y1) / (c1 - AccurateMath.sqrt(delta));
+            final double xplus = x1 + (-2.0 * y1) / (c1 + JdkMath.sqrt(delta));
+            final double xminus = x1 + (-2.0 * y1) / (c1 - JdkMath.sqrt(delta));
             // xplus and xminus are two roots of parabola and at least
             // one of them should lie in (x0, x2)
             final double x = isSequence(x0, xplus, x2) ? xplus : xminus;
             final double y = computeObjectiveValue(x);
 
             // check for convergence
-            final double tolerance = AccurateMath.max(relativeAccuracy * AccurateMath.abs(x), absoluteAccuracy);
-            if (AccurateMath.abs(x - oldx) <= tolerance ||
-                AccurateMath.abs(y) <= functionValueAccuracy) {
+            final double tolerance = JdkMath.max(relativeAccuracy * JdkMath.abs(x), absoluteAccuracy);
+            if (JdkMath.abs(x - oldx) <= tolerance ||
+                JdkMath.abs(y) <= functionValueAccuracy) {
                 return x;
             }
 
@@ -188,7 +188,7 @@
             } else {
                 double xm = 0.5 * (x0 + x2);
                 double ym = computeObjectiveValue(xm);
-                if (AccurateMath.signum(y0) + AccurateMath.signum(ym) == 0.0) {
+                if (JdkMath.signum(y0) + JdkMath.signum(ym) == 0.0) {
                     x2 = xm; y2 = ym;
                 } else {
                     x0 = xm; y0 = ym;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/MullerSolver2.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/MullerSolver2.java
index e137ef8..fd8d3e5 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/MullerSolver2.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/MullerSolver2.java
@@ -19,7 +19,7 @@
 import org.apache.commons.math4.legacy.exception.NoBracketingException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
 import org.apache.commons.math4.legacy.exception.TooManyEvaluationsException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * This class implements the <a href="http://mathworld.wolfram.com/MullersMethod.html">
@@ -99,12 +99,12 @@
 
         double x0 = min;
         double y0 = computeObjectiveValue(x0);
-        if (AccurateMath.abs(y0) < functionValueAccuracy) {
+        if (JdkMath.abs(y0) < functionValueAccuracy) {
             return x0;
         }
         double x1 = max;
         double y1 = computeObjectiveValue(x1);
-        if (AccurateMath.abs(y1) < functionValueAccuracy) {
+        if (JdkMath.abs(y1) < functionValueAccuracy) {
             return x1;
         }
 
@@ -127,12 +127,12 @@
             final double denominator;
             if (delta >= 0.0) {
                 // choose a denominator larger in magnitude
-                double dplus = b + AccurateMath.sqrt(delta);
-                double dminus = b - AccurateMath.sqrt(delta);
-                denominator = AccurateMath.abs(dplus) > AccurateMath.abs(dminus) ? dplus : dminus;
+                double dplus = b + JdkMath.sqrt(delta);
+                double dminus = b - JdkMath.sqrt(delta);
+                denominator = JdkMath.abs(dplus) > JdkMath.abs(dminus) ? dplus : dminus;
             } else {
-                // take the modulus of (B +/- AccurateMath.sqrt(delta))
-                denominator = AccurateMath.sqrt(b * b - delta);
+                // take the modulus of (B +/- JdkMath.sqrt(delta))
+                denominator = JdkMath.sqrt(b * b - delta);
             }
             if (denominator != 0) {
                 x = x2 - 2.0 * c * (x2 - x1) / denominator;
@@ -143,15 +143,15 @@
                 }
             } else {
                 // extremely rare case, get a random number to skip it
-                x = min + AccurateMath.random() * (max - min);
+                x = min + JdkMath.random() * (max - min);
                 oldx = Double.POSITIVE_INFINITY;
             }
             final double y = computeObjectiveValue(x);
 
             // check for convergence
-            final double tolerance = AccurateMath.max(relativeAccuracy * AccurateMath.abs(x), absoluteAccuracy);
-            if (AccurateMath.abs(x - oldx) <= tolerance ||
-                AccurateMath.abs(y) <= functionValueAccuracy) {
+            final double tolerance = JdkMath.max(relativeAccuracy * JdkMath.abs(x), absoluteAccuracy);
+            if (JdkMath.abs(x - oldx) <= tolerance ||
+                JdkMath.abs(y) <= functionValueAccuracy) {
                 return x;
             }
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/NewtonRaphsonSolver.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/NewtonRaphsonSolver.java
index 4b29826..4b5c548 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/NewtonRaphsonSolver.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/NewtonRaphsonSolver.java
@@ -20,7 +20,7 @@
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
 import org.apache.commons.math4.legacy.exception.TooManyEvaluationsException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Implements <a href="http://mathworld.wolfram.com/NewtonsMethod.html">
@@ -82,7 +82,7 @@
         while (true) {
             final DerivativeStructure y0 = computeObjectiveValueAndDerivative(x0);
             x1 = x0 - (y0.getValue() / y0.getPartialDerivative(1));
-            if (AccurateMath.abs(x1 - x0) <= absoluteAccuracy) {
+            if (JdkMath.abs(x1 - x0) <= absoluteAccuracy) {
                 return x1;
             }
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/RiddersSolver.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/RiddersSolver.java
index 8b05975..4a73eb1 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/RiddersSolver.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/RiddersSolver.java
@@ -18,7 +18,7 @@
 
 import org.apache.commons.math4.legacy.exception.NoBracketingException;
 import org.apache.commons.math4.legacy.exception.TooManyEvaluationsException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Implements the <a href="http://mathworld.wolfram.com/RiddersMethod.html">
@@ -95,28 +95,28 @@
             // calculate the new root approximation
             final double x3 = 0.5 * (x1 + x2);
             final double y3 = computeObjectiveValue(x3);
-            if (AccurateMath.abs(y3) <= functionValueAccuracy) {
+            if (JdkMath.abs(y3) <= functionValueAccuracy) {
                 return x3;
             }
             final double delta = 1 - (y1 * y2) / (y3 * y3);  // delta > 1 due to bracketing
-            final double correction = (AccurateMath.signum(y2) * AccurateMath.signum(y3)) *
-                                      (x3 - x1) / AccurateMath.sqrt(delta);
+            final double correction = (JdkMath.signum(y2) * JdkMath.signum(y3)) *
+                                      (x3 - x1) / JdkMath.sqrt(delta);
             final double x = x3 - correction;                // correction != 0
             final double y = computeObjectiveValue(x);
 
             // check for convergence
-            final double tolerance = AccurateMath.max(relativeAccuracy * AccurateMath.abs(x), absoluteAccuracy);
-            if (AccurateMath.abs(x - oldx) <= tolerance) {
+            final double tolerance = JdkMath.max(relativeAccuracy * JdkMath.abs(x), absoluteAccuracy);
+            if (JdkMath.abs(x - oldx) <= tolerance) {
                 return x;
             }
-            if (AccurateMath.abs(y) <= functionValueAccuracy) {
+            if (JdkMath.abs(y) <= functionValueAccuracy) {
                 return x;
             }
 
             // prepare the new interval for next iteration
             // Ridders' method guarantees x1 < x < x2
             if (correction > 0.0) {             // x1 < x < x3
-                if (AccurateMath.signum(y1) + AccurateMath.signum(y) == 0.0) {
+                if (JdkMath.signum(y1) + JdkMath.signum(y) == 0.0) {
                     x2 = x;
                     y2 = y;
                 } else {
@@ -126,7 +126,7 @@
                     y2 = y3;
                 }
             } else {                            // x3 < x < x2
-                if (AccurateMath.signum(y2) + AccurateMath.signum(y) == 0.0) {
+                if (JdkMath.signum(y2) + JdkMath.signum(y) == 0.0) {
                     x1 = x;
                     y1 = y;
                 } else {
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/SecantSolver.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/SecantSolver.java
index 5c1e241..14d9cb2 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/SecantSolver.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/SecantSolver.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.exception.NoBracketingException;
 import org.apache.commons.math4.legacy.exception.TooManyEvaluationsException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Implements the <em>Secant</em> method for root-finding (approximating a
@@ -120,13 +120,13 @@
             // If the function value of the last approximation is too small,
             // given the function value accuracy, then we can't get closer to
             // the root than we already are.
-            if (AccurateMath.abs(f1) <= ftol) {
+            if (JdkMath.abs(f1) <= ftol) {
                 return x1;
             }
 
             // If the current interval is within the given accuracies, we
             // are satisfied with the current approximation.
-            if (AccurateMath.abs(x1 - x0) < AccurateMath.max(rtol * AccurateMath.abs(x1), atol)) {
+            if (JdkMath.abs(x1 - x0) < JdkMath.max(rtol * JdkMath.abs(x1), atol)) {
                 return x1;
             }
         }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/UnivariateSolverUtils.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/UnivariateSolverUtils.java
index daace2d..d8cfdb9 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/UnivariateSolverUtils.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/UnivariateSolverUtils.java
@@ -22,7 +22,7 @@
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Utility routines for {@link UnivariateSolver} objects.
@@ -111,11 +111,11 @@
         }
 
         // find a very small interval bracketing the root
-        final double step = AccurateMath.max(bracketing.getAbsoluteAccuracy(),
-                                         AccurateMath.abs(baseRoot * bracketing.getRelativeAccuracy()));
-        double xLo        = AccurateMath.max(min, baseRoot - step);
+        final double step = JdkMath.max(bracketing.getAbsoluteAccuracy(),
+                                         JdkMath.abs(baseRoot * bracketing.getRelativeAccuracy()));
+        double xLo        = JdkMath.max(min, baseRoot - step);
         double fLo        = f.value(xLo);
-        double xHi        = AccurateMath.min(max, baseRoot + step);
+        double xHi        = JdkMath.min(max, baseRoot + step);
         double fHi        = f.value(xHi);
         int remainingEval = maxEval - 2;
         while (remainingEval > 0) {
@@ -150,14 +150,14 @@
 
             // update the lower bound
             if (changeLo) {
-                xLo = AccurateMath.max(min, xLo - step);
+                xLo = JdkMath.max(min, xLo - step);
                 fLo  = f.value(xLo);
                 remainingEval--;
             }
 
             // update the higher bound
             if (changeHi) {
-                xHi = AccurateMath.min(max, xHi + step);
+                xHi = JdkMath.min(max, xHi + step);
                 fHi  = f.value(xHi);
                 remainingEval--;
             }
@@ -325,8 +325,8 @@
             final double previousFb = fb;
 
             delta = r * delta + q;
-            a     = AccurateMath.max(initial - delta, lowerBound);
-            b     = AccurateMath.min(initial + delta, upperBound);
+            a     = JdkMath.max(initial - delta, lowerBound);
+            b     = JdkMath.min(initial + delta, upperBound);
             fa    = function.value(a);
             fb    = function.value(b);
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/AbstractIntegerDistribution.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/AbstractIntegerDistribution.java
index f4a0402..15a7c53 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/AbstractIntegerDistribution.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/AbstractIntegerDistribution.java
@@ -25,7 +25,7 @@
 import org.apache.commons.rng.sampling.distribution.InverseTransformDiscreteSampler;
 import org.apache.commons.rng.sampling.distribution.DiscreteInverseCumulativeProbabilityFunction;
 import org.apache.commons.rng.sampling.distribution.DiscreteSampler;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Base class for integer-valued discrete distributions.  Default
@@ -90,19 +90,19 @@
         // use the one-sided Chebyshev inequality to narrow the bracket
         // cf. AbstractRealDistribution.inverseCumulativeProbability(double)
         final double mu = getMean();
-        final double sigma = AccurateMath.sqrt(getVariance());
+        final double sigma = JdkMath.sqrt(getVariance());
         final boolean chebyshevApplies = !(Double.isInfinite(mu) || Double.isNaN(mu) ||
                 Double.isInfinite(sigma) || Double.isNaN(sigma) || sigma == 0.0);
         if (chebyshevApplies) {
-            double k = AccurateMath.sqrt((1.0 - p) / p);
+            double k = JdkMath.sqrt((1.0 - p) / p);
             double tmp = mu - k * sigma;
             if (tmp > lower) {
-                lower = ((int) AccurateMath.ceil(tmp)) - 1;
+                lower = ((int) JdkMath.ceil(tmp)) - 1;
             }
             k = 1.0 / k;
             tmp = mu + k * sigma;
             if (tmp < upper) {
-                upper = ((int) AccurateMath.ceil(tmp)) - 1;
+                upper = ((int) JdkMath.ceil(tmp)) - 1;
             }
         }
 
@@ -171,7 +171,7 @@
      */
     @Override
     public double logProbability(int x) {
-        return AccurateMath.log(probability(x));
+        return JdkMath.log(probability(x));
     }
 
     /**
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/AbstractRealDistribution.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/AbstractRealDistribution.java
index e422e17..3d79914 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/AbstractRealDistribution.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/AbstractRealDistribution.java
@@ -26,7 +26,7 @@
 import org.apache.commons.rng.sampling.distribution.InverseTransformContinuousSampler;
 import org.apache.commons.rng.sampling.distribution.ContinuousInverseCumulativeProbabilityFunction;
 import org.apache.commons.rng.sampling.distribution.ContinuousSampler;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Base class for probability distributions on the reals.
@@ -129,14 +129,14 @@
         }
 
         final double mu = getMean();
-        final double sig = AccurateMath.sqrt(getVariance());
+        final double sig = JdkMath.sqrt(getVariance());
         final boolean chebyshevApplies;
         chebyshevApplies = !(Double.isInfinite(mu) || Double.isNaN(mu) ||
                              Double.isInfinite(sig) || Double.isNaN(sig));
 
         if (lowerBound == Double.NEGATIVE_INFINITY) {
             if (chebyshevApplies) {
-                lowerBound = mu - sig * AccurateMath.sqrt((1. - p) / p);
+                lowerBound = mu - sig * JdkMath.sqrt((1. - p) / p);
             } else {
                 lowerBound = -1.0;
                 while (cumulativeProbability(lowerBound) >= p) {
@@ -147,7 +147,7 @@
 
         if (upperBound == Double.POSITIVE_INFINITY) {
             if (chebyshevApplies) {
-                upperBound = mu + sig * AccurateMath.sqrt(p / (1. - p));
+                upperBound = mu + sig * JdkMath.sqrt(p / (1. - p));
             } else {
                 upperBound = 1.0;
                 while (cumulativeProbability(upperBound) < p) {
@@ -209,7 +209,7 @@
      */
     @Override
     public double logDensity(double x) {
-        return AccurateMath.log(density(x));
+        return JdkMath.log(density(x));
     }
 
     /**
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/EmpiricalDistribution.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/EmpiricalDistribution.java
index 8058ea5..f3bf604 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/EmpiricalDistribution.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/EmpiricalDistribution.java
@@ -29,7 +29,7 @@
 import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
 import org.apache.commons.math4.legacy.stat.descriptive.StatisticalSummary;
 import org.apache.commons.math4.legacy.stat.descriptive.SummaryStatistics;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * <p>Represents an <a href="http://en.wikipedia.org/wiki/Empirical_distribution_function">
@@ -207,7 +207,7 @@
      * @return the index of the bin containing the value.
      */
     private int findBin(double value) {
-        return Math.min(Math.max((int) AccurateMath.ceil((value - min) / delta) - 1,
+        return Math.min(Math.max((int) JdkMath.ceil((value - min) / delta) - 1,
                                  0),
                         binCount - 1);
     }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/MultivariateNormalDistribution.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/MultivariateNormalDistribution.java
index b216816..8470f95 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/MultivariateNormalDistribution.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/MultivariateNormalDistribution.java
@@ -26,7 +26,7 @@
 import org.apache.commons.math4.legacy.linear.RealMatrix;
 import org.apache.commons.math4.legacy.linear.SingularMatrixException;
 import org.apache.commons.rng.UniformRandomProvider;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Implementation of the multivariate normal (Gaussian) distribution.
@@ -120,7 +120,7 @@
 
         // Scale each eigenvector by the square root of its eigenvalue.
         for (int row = 0; row < dim; row++) {
-            final double factor = AccurateMath.sqrt(covMatEigenvalues[row]);
+            final double factor = JdkMath.sqrt(covMatEigenvalues[row]);
             for (int col = 0; col < dim; col++) {
                 tmpMatrix.multiplyEntry(row, col, factor);
             }
@@ -155,8 +155,8 @@
             throw new DimensionMismatchException(vals.length, dim);
         }
 
-        return AccurateMath.pow(2 * AccurateMath.PI, -0.5 * dim) *
-            AccurateMath.pow(covarianceMatrixDeterminant, -0.5) *
+        return JdkMath.pow(2 * JdkMath.PI, -0.5 * dim) *
+            JdkMath.pow(covarianceMatrixDeterminant, -0.5) *
             getExponentTerm(vals);
     }
 
@@ -171,7 +171,7 @@
         final double[] std = new double[dim];
         final double[][] s = covarianceMatrix.getData();
         for (int i = 0; i < dim; i++) {
-            std[i] = AccurateMath.sqrt(s[i][i]);
+            std[i] = JdkMath.sqrt(s[i][i]);
         }
         return std;
     }
@@ -220,6 +220,6 @@
         for (int i = 0; i < preMultiplied.length; i++) {
             sum += preMultiplied[i] * centered[i];
         }
-        return AccurateMath.exp(-0.5 * sum);
+        return JdkMath.exp(-0.5 * sum);
     }
 }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/fitting/MultivariateNormalMixtureExpectationMaximization.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/fitting/MultivariateNormalMixtureExpectationMaximization.java
index 450a1ba..afca6ea 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/fitting/MultivariateNormalMixtureExpectationMaximization.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/distribution/fitting/MultivariateNormalMixtureExpectationMaximization.java
@@ -32,7 +32,7 @@
 import org.apache.commons.math4.legacy.linear.RealMatrix;
 import org.apache.commons.math4.legacy.linear.SingularMatrixException;
 import org.apache.commons.math4.legacy.stat.correlation.Covariance;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 import org.apache.commons.math4.legacy.core.Pair;
 
@@ -166,7 +166,7 @@
         fittedModel = new MixtureMultivariateNormalDistribution(initialMixture.getComponents());
 
         while (numIterations++ <= maxIterations &&
-               AccurateMath.abs(previousLogLikelihood - logLikelihood) > threshold) {
+               JdkMath.abs(previousLogLikelihood - logLikelihood) > threshold) {
             previousLogLikelihood = logLikelihood;
             double sumLogLikelihood = 0d;
 
@@ -198,7 +198,7 @@
 
             for (int i = 0; i < n; i++) {
                 final double rowDensity = fittedModel.density(data[i]);
-                sumLogLikelihood += AccurateMath.log(rowDensity);
+                sumLogLikelihood += JdkMath.log(rowDensity);
 
                 for (int j = 0; j < k; j++) {
                     gamma[i][j] = weights[j] * mvns[j].density(data[i]) / rowDensity;
@@ -252,7 +252,7 @@
                                                                     newCovMatArrays);
         }
 
-        if (AccurateMath.abs(previousLogLikelihood - logLikelihood) > threshold) {
+        if (JdkMath.abs(previousLogLikelihood - logLikelihood) > threshold) {
             // Did not converge before the maximum number of iterations
             throw new ConvergenceException();
         }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/GaussianCurveFitter.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/GaussianCurveFitter.java
index 28e3170..b35cf62 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/GaussianCurveFitter.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/GaussianCurveFitter.java
@@ -25,7 +25,7 @@
 import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Fits points to a {@link
@@ -173,7 +173,7 @@
                 // TODO: Exceptions should not be used for flow control.
                 fwhmApprox = points[points.length - 1].getX() - points[0].getX();
             }
-            final double s = fwhmApprox / (2 * AccurateMath.sqrt(2 * AccurateMath.log(2)));
+            final double s = fwhmApprox / (2 * JdkMath.sqrt(2 * JdkMath.log(2)));
 
             return new double[] { n, points[maxYIdx].getX(), s };
         }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/HarmonicCurveFitter.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/HarmonicCurveFitter.java
index c29a14c..f186d98 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/HarmonicCurveFitter.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/HarmonicCurveFitter.java
@@ -22,7 +22,7 @@
 import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
 import org.apache.commons.math4.legacy.exception.ZeroException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Fits points to a {@link
@@ -288,8 +288,8 @@
                     throw new MathIllegalStateException(LocalizedFormats.ZERO_DENOMINATOR);
                 }
 
-                aOmega[0] = AccurateMath.sqrt(c1 / c2);
-                aOmega[1] = AccurateMath.sqrt(c2 / c3);
+                aOmega[0] = JdkMath.sqrt(c1 / c2);
+                aOmega[1] = JdkMath.sqrt(c2 / c3);
             }
 
             return aOmega;
@@ -319,13 +319,13 @@
                 final double currentYPrime = (currentY - previousY) / (currentX - previousX);
 
                 double omegaX = omega * currentX;
-                double cosine = AccurateMath.cos(omegaX);
-                double sine = AccurateMath.sin(omegaX);
+                double cosine = JdkMath.cos(omegaX);
+                double sine = JdkMath.sin(omegaX);
                 fcMean += omega * currentY * cosine - currentYPrime * sine;
                 fsMean += omega * currentY * sine + currentYPrime * cosine;
             }
 
-            return AccurateMath.atan2(-fsMean, fcMean);
+            return JdkMath.atan2(-fsMean, fcMean);
         }
     }
 }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/leastsquares/AbstractEvaluation.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/leastsquares/AbstractEvaluation.java
index bb881e0..9509ab7 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/leastsquares/AbstractEvaluation.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/leastsquares/AbstractEvaluation.java
@@ -22,7 +22,7 @@
 import org.apache.commons.math4.legacy.linear.QRDecomposition;
 import org.apache.commons.math4.legacy.linear.RealMatrix;
 import org.apache.commons.math4.legacy.linear.RealVector;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * An implementation of {@link Evaluation} that is designed for extension. All of the
@@ -69,7 +69,7 @@
         final int nC = cov.getColumnDimension();
         final RealVector sig = new ArrayRealVector(nC);
         for (int i = 0; i < nC; ++i) {
-            sig.setEntry(i, AccurateMath.sqrt(cov.getEntry(i,i)));
+            sig.setEntry(i, JdkMath.sqrt(cov.getEntry(i,i)));
         }
         return sig;
     }
@@ -77,13 +77,13 @@
     /** {@inheritDoc} */
     @Override
     public double getRMS() {
-        return AccurateMath.sqrt(getReducedChiSquare(1));
+        return JdkMath.sqrt(getReducedChiSquare(1));
     }
 
     /** {@inheritDoc} */
     @Override
     public double getCost() {
-        return AccurateMath.sqrt(getChiSquare());
+        return JdkMath.sqrt(getChiSquare());
     }
 
     /** {@inheritDoc} */
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/leastsquares/LeastSquaresFactory.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/leastsquares/LeastSquaresFactory.java
index c923c09..415a753 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/leastsquares/LeastSquaresFactory.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/leastsquares/LeastSquaresFactory.java
@@ -30,7 +30,7 @@
 import org.apache.commons.math4.legacy.optim.AbstractOptimizationProblem;
 import org.apache.commons.math4.legacy.optim.ConvergenceChecker;
 import org.apache.commons.math4.legacy.optim.PointVectorValuePair;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.IntegerSequence;
 import org.apache.commons.math4.legacy.core.Pair;
 
@@ -278,7 +278,7 @@
             final int dim = m.getRowDimension();
             final RealMatrix sqrtM = new DiagonalMatrix(dim);
             for (int i = 0; i < dim; i++) {
-                sqrtM.setEntry(i, i, AccurateMath.sqrt(m.getEntry(i, i)));
+                sqrtM.setEntry(i, i, JdkMath.sqrt(m.getEntry(i, i)));
             }
             return sqrtM;
         } else {
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/leastsquares/LevenbergMarquardtOptimizer.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/leastsquares/LevenbergMarquardtOptimizer.java
index 2ca7e2c..14518e6 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/leastsquares/LevenbergMarquardtOptimizer.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/fitting/leastsquares/LevenbergMarquardtOptimizer.java
@@ -24,7 +24,7 @@
 import org.apache.commons.math4.legacy.linear.ArrayRealVector;
 import org.apache.commons.math4.legacy.linear.RealMatrix;
 import org.apache.commons.math4.legacy.optim.ConvergenceChecker;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.IntegerSequence;
 import org.apache.commons.numbers.core.Precision;
 
@@ -305,7 +305,7 @@
         final ConvergenceChecker<Evaluation> checker = problem.getConvergenceChecker();
 
         // arrays shared with the other private methods
-        final int solvedCols  = AccurateMath.min(nR, nC);
+        final int solvedCols  = JdkMath.min(nR, nC);
         /* Parameters evolution direction associated with lmPar. */
         double[] lmDir = new double[nC];
         /* Levenberg-Marquardt parameter. */
@@ -375,7 +375,7 @@
                     xNorm  += xk * xk;
                     diag[k] = dk;
                 }
-                xNorm = AccurateMath.sqrt(xNorm);
+                xNorm = JdkMath.sqrt(xNorm);
 
                 // initialize the step bound delta
                 delta = (xNorm == 0) ? initialStepBoundFactor : (initialStepBoundFactor * xNorm);
@@ -392,7 +392,7 @@
                         for (int i = 0; i <= j; ++i) {
                             sum += weightedJacobian[i][pj] * qtf[i];
                         }
-                        maxCosine = AccurateMath.max(maxCosine, AccurateMath.abs(sum) / (s * currentCost));
+                        maxCosine = JdkMath.max(maxCosine, JdkMath.abs(sum) / (s * currentCost));
                     }
                 }
             }
@@ -406,7 +406,7 @@
 
             // rescale if necessary
             for (int j = 0; j < nC; ++j) {
-                diag[j] = AccurateMath.max(diag[j], jacNorm[j]);
+                diag[j] = JdkMath.max(diag[j], jacNorm[j]);
             }
 
             // Inner loop.
@@ -436,10 +436,10 @@
                     double s = diag[pj] * lmDir[pj];
                     lmNorm  += s * s;
                 }
-                lmNorm = AccurateMath.sqrt(lmNorm);
+                lmNorm = JdkMath.sqrt(lmNorm);
                 // on the first iteration, adjust the initial step bound.
                 if (firstIteration) {
-                    delta = AccurateMath.min(delta, lmNorm);
+                    delta = JdkMath.min(delta, lmNorm);
                 }
 
                 // Evaluate the function at x + p and calculate its norm.
@@ -486,7 +486,7 @@
                         if ((0.1 * currentCost >= previousCost) || (tmp < 0.1)) {
                             tmp = 0.1;
                         }
-                        delta = tmp * AccurateMath.min(delta, 10.0 * lmNorm);
+                        delta = tmp * JdkMath.min(delta, 10.0 * lmNorm);
                         lmPar /= tmp;
                 } else if ((lmPar == 0) || (ratio >= 0.75)) {
                     delta = 2 * lmNorm;
@@ -502,7 +502,7 @@
                         double xK = diag[k] * currentPoint[k];
                         xNorm += xK * xK;
                     }
-                    xNorm = AccurateMath.sqrt(xNorm);
+                    xNorm = JdkMath.sqrt(xNorm);
 
                     // tests for convergence.
                     if (checker != null && checker.converged(iterationCounter.getCount(), previous, current)) {
@@ -523,7 +523,7 @@
                 }
 
                 // Default convergence criteria.
-                if ((AccurateMath.abs(actRed) <= costRelativeTolerance &&
+                if ((JdkMath.abs(actRed) <= costRelativeTolerance &&
                      preRed <= costRelativeTolerance &&
                      ratio <= 2.0) ||
                     delta <= parRelativeTolerance * xNorm) {
@@ -531,7 +531,7 @@
                 }
 
                 // tests for termination and stringent tolerances
-                if (AccurateMath.abs(actRed) <= TWO_EPS &&
+                if (JdkMath.abs(actRed) <= TWO_EPS &&
                     preRed <= TWO_EPS &&
                     ratio <= 2.0) {
                     throw new ConvergenceException(LocalizedFormats.TOO_SMALL_COST_RELATIVE_TOLERANCE,
@@ -655,7 +655,7 @@
             work1[pj] = s;
             dxNorm += s * s;
         }
-        dxNorm = AccurateMath.sqrt(dxNorm);
+        dxNorm = JdkMath.sqrt(dxNorm);
         double fp = dxNorm - delta;
         if (fp <= 0.1 * delta) {
             lmPar = 0;
@@ -697,15 +697,15 @@
             sum /= diag[pj];
             sum2 += sum * sum;
         }
-        double gNorm = AccurateMath.sqrt(sum2);
+        double gNorm = JdkMath.sqrt(sum2);
         double paru = gNorm / delta;
         if (paru == 0) {
-            paru = Precision.SAFE_MIN / AccurateMath.min(delta, 0.1);
+            paru = Precision.SAFE_MIN / JdkMath.min(delta, 0.1);
         }
 
         // if the input par lies outside of the interval (parl,paru),
         // set par to the closer endpoint
-        lmPar = AccurateMath.min(paru, AccurateMath.max(lmPar, parl));
+        lmPar = JdkMath.min(paru, JdkMath.max(lmPar, parl));
         if (lmPar == 0) {
             lmPar = gNorm / dxNorm;
         }
@@ -714,9 +714,9 @@
 
             // evaluate the function at the current value of lmPar
             if (lmPar == 0) {
-                lmPar = AccurateMath.max(Precision.SAFE_MIN, 0.001 * paru);
+                lmPar = JdkMath.max(Precision.SAFE_MIN, 0.001 * paru);
             }
-            double sPar = AccurateMath.sqrt(lmPar);
+            double sPar = JdkMath.sqrt(lmPar);
             for (int j = 0; j < solvedCols; ++j) {
                 int pj = permutation[j];
                 work1[pj] = sPar * diag[pj];
@@ -730,13 +730,13 @@
                 work3[pj] = s;
                 dxNorm += s * s;
             }
-            dxNorm = AccurateMath.sqrt(dxNorm);
+            dxNorm = JdkMath.sqrt(dxNorm);
             double previousFP = fp;
             fp = dxNorm - delta;
 
             // if the function is small enough, accept the current value
             // of lmPar, also test for the exceptional cases where parl is zero
-            if (AccurateMath.abs(fp) <= 0.1 * delta ||
+            if (JdkMath.abs(fp) <= 0.1 * delta ||
                 (parl == 0 &&
                  fp <= previousFP &&
                  previousFP < 0)) {
@@ -765,13 +765,13 @@
 
             // depending on the sign of the function, update parl or paru.
             if (fp > 0) {
-                parl = AccurateMath.max(parl, lmPar);
+                parl = JdkMath.max(parl, lmPar);
             } else if (fp < 0) {
-                paru = AccurateMath.min(paru, lmPar);
+                paru = JdkMath.min(paru, lmPar);
             }
 
             // compute an improved estimate for lmPar
-            lmPar = AccurateMath.max(parl, lmPar + correction);
+            lmPar = JdkMath.max(parl, lmPar + correction);
         }
 
         return lmPar;
@@ -847,13 +847,13 @@
                     final double sin;
                     final double cos;
                     double rkk = weightedJacobian[k][pk];
-                    if (AccurateMath.abs(rkk) < AccurateMath.abs(lmDiag[k])) {
+                    if (JdkMath.abs(rkk) < JdkMath.abs(lmDiag[k])) {
                         final double cotan = rkk / lmDiag[k];
-                        sin   = 1.0 / AccurateMath.sqrt(1.0 + cotan * cotan);
+                        sin   = 1.0 / JdkMath.sqrt(1.0 + cotan * cotan);
                         cos   = sin * cotan;
                     } else {
                         final double tan = lmDiag[k] / rkk;
-                        cos = 1.0 / AccurateMath.sqrt(1.0 + tan * tan);
+                        cos = 1.0 / JdkMath.sqrt(1.0 + tan * tan);
                         sin = cos * tan;
                     }
 
@@ -956,7 +956,7 @@
                 double akk = weightedJacobian[i][k];
                 norm2 += akk * akk;
             }
-            jacNorm[k] = AccurateMath.sqrt(norm2);
+            jacNorm[k] = JdkMath.sqrt(norm2);
         }
 
         // transform the matrix column after column
@@ -989,7 +989,7 @@
 
             // choose alpha such that Hk.u = alpha ek
             double akk = weightedJacobian[k][pk];
-            double alpha = (akk > 0) ? -AccurateMath.sqrt(ak2) : AccurateMath.sqrt(ak2);
+            double alpha = (akk > 0) ? -JdkMath.sqrt(ak2) : JdkMath.sqrt(ak2);
             double betak = 1.0 / (ak2 - akk * alpha);
             beta[pk] = betak;
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/genetics/ElitisticListPopulation.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/genetics/ElitisticListPopulation.java
index 59f5288..8361607 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/genetics/ElitisticListPopulation.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/genetics/ElitisticListPopulation.java
@@ -24,7 +24,7 @@
 import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Population of chromosomes which uses elitism (certain percentage of the best
@@ -87,7 +87,7 @@
         Collections.sort(oldChromosomes);
 
         // index of the last "not good enough" chromosome
-        int boundIndex = (int) AccurateMath.ceil((1.0 - getElitismRate()) * oldChromosomes.size());
+        int boundIndex = (int) JdkMath.ceil((1.0 - getElitismRate()) * oldChromosomes.size());
         for (int i = boundIndex; i < oldChromosomes.size(); i++) {
             nextGeneration.addChromosome(oldChromosomes.get(i));
         }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/genetics/OrderedCrossover.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/genetics/OrderedCrossover.java
index c28c253..7669b55 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/genetics/OrderedCrossover.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/genetics/OrderedCrossover.java
@@ -26,7 +26,7 @@
 import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
 import org.apache.commons.rng.UniformRandomProvider;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Order 1 Crossover [OX1] builds offspring from <b>ordered</b> chromosomes by copying a
@@ -111,8 +111,8 @@
             b = random.nextInt(length);
         } while (a == b);
         // determine the lower and upper bounds
-        final int lb = AccurateMath.min(a, b);
-        final int ub = AccurateMath.max(a, b);
+        final int lb = JdkMath.min(a, b);
+        final int ub = JdkMath.max(a, b);
 
         // add the subLists that are between lb and ub
         child1.addAll(parent1Rep.subList(lb, ub + 1));
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/AbstractRealMatrix.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/AbstractRealMatrix.java
index 23bacf2..6373041 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/AbstractRealMatrix.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/AbstractRealMatrix.java
@@ -28,7 +28,7 @@
 import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Basic implementation of RealMatrix methods regardless of the underlying storage.
@@ -270,9 +270,9 @@
             /** {@inheritDoc} */
             @Override
             public void visit(final int row, final int column, final double value) {
-                columnSum += AccurateMath.abs(value);
+                columnSum += JdkMath.abs(value);
                 if (row == endRow) {
-                    maxColSum = AccurateMath.max(maxColSum, columnSum);
+                    maxColSum = JdkMath.max(maxColSum, columnSum);
                     columnSum = 0;
                 }
             }
@@ -310,7 +310,7 @@
             /** {@inheritDoc} */
             @Override
             public double end() {
-                return AccurateMath.sqrt(sum);
+                return JdkMath.sqrt(sum);
             }
         });
     }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/ArrayRealVector.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/ArrayRealVector.java
index 0858c86..13a49dd 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/ArrayRealVector.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/ArrayRealVector.java
@@ -28,7 +28,7 @@
 import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * This class implements the {@link RealVector} interface with a double array.
@@ -470,7 +470,7 @@
         for (double a : data) {
             sum += a * a;
         }
-        return AccurateMath.sqrt(sum);
+        return JdkMath.sqrt(sum);
     }
 
     /** {@inheritDoc} */
@@ -478,7 +478,7 @@
     public double getL1Norm() {
         double sum = 0;
         for (double a : data) {
-            sum += AccurateMath.abs(a);
+            sum += JdkMath.abs(a);
         }
         return sum;
     }
@@ -488,7 +488,7 @@
     public double getLInfNorm() {
         double max = 0;
         for (double a : data) {
-            max = AccurateMath.max(max, AccurateMath.abs(a));
+            max = JdkMath.max(max, JdkMath.abs(a));
         }
         return max;
     }
@@ -504,7 +504,7 @@
                 final double delta = data[i] - vData[i];
                 sum += delta * delta;
             }
-            return AccurateMath.sqrt(sum);
+            return JdkMath.sqrt(sum);
         } else {
             checkVectorDimensions(v);
             double sum = 0;
@@ -512,7 +512,7 @@
                 final double delta = data[i] - v.getEntry(i);
                 sum += delta * delta;
             }
-            return AccurateMath.sqrt(sum);
+            return JdkMath.sqrt(sum);
         }
     }
 
@@ -526,7 +526,7 @@
             double sum = 0;
             for (int i = 0; i < data.length; ++i) {
                 final double delta = data[i] - vData[i];
-                sum += AccurateMath.abs(delta);
+                sum += JdkMath.abs(delta);
             }
             return sum;
         } else {
@@ -534,7 +534,7 @@
             double sum = 0;
             for (int i = 0; i < data.length; ++i) {
                 final double delta = data[i] - v.getEntry(i);
-                sum += AccurateMath.abs(delta);
+                sum += JdkMath.abs(delta);
             }
             return sum;
         }
@@ -550,7 +550,7 @@
             double max = 0;
             for (int i = 0; i < data.length; ++i) {
                 final double delta = data[i] - vData[i];
-                max = AccurateMath.max(max, AccurateMath.abs(delta));
+                max = JdkMath.max(max, JdkMath.abs(delta));
             }
             return max;
         } else {
@@ -558,7 +558,7 @@
             double max = 0;
             for (int i = 0; i < data.length; ++i) {
                 final double delta = data[i] - v.getEntry(i);
-                max = AccurateMath.max(max, AccurateMath.abs(delta));
+                max = JdkMath.max(max, JdkMath.abs(delta));
             }
             return max;
         }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/BiDiagonalTransformer.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/BiDiagonalTransformer.java
index e0630a0..2eee0c0 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/BiDiagonalTransformer.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/BiDiagonalTransformer.java
@@ -17,7 +17,7 @@
 
 package org.apache.commons.math4.legacy.linear;
 
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 
 /**
@@ -62,7 +62,7 @@
 
         final int m = matrix.getRowDimension();
         final int n = matrix.getColumnDimension();
-        final int p = AccurateMath.min(m, n);
+        final int p = JdkMath.min(m, n);
         householderVectors = matrix.getData();
         main      = new double[p];
         secondary = new double[p - 1];
@@ -266,7 +266,7 @@
                 xNormSqr += c * c;
             }
             final double[] hK = householderVectors[k];
-            final double a = (hK[k] > 0) ? -AccurateMath.sqrt(xNormSqr) : AccurateMath.sqrt(xNormSqr);
+            final double a = (hK[k] > 0) ? -JdkMath.sqrt(xNormSqr) : JdkMath.sqrt(xNormSqr);
             main[k] = a;
             if (a != 0.0) {
                 hK[k] -= a;
@@ -291,7 +291,7 @@
                     final double c = hK[j];
                     xNormSqr += c * c;
                 }
-                final double b = (hK[k + 1] > 0) ? -AccurateMath.sqrt(xNormSqr) : AccurateMath.sqrt(xNormSqr);
+                final double b = (hK[k + 1] > 0) ? -JdkMath.sqrt(xNormSqr) : JdkMath.sqrt(xNormSqr);
                 secondary[k] = b;
                 if (b != 0.0) {
                     hK[k + 1] -= b;
@@ -330,7 +330,7 @@
                 final double c = hK[j];
                 xNormSqr += c * c;
             }
-            final double a = (hK[k] > 0) ? -AccurateMath.sqrt(xNormSqr) : AccurateMath.sqrt(xNormSqr);
+            final double a = (hK[k] > 0) ? -JdkMath.sqrt(xNormSqr) : JdkMath.sqrt(xNormSqr);
             main[k] = a;
             if (a != 0.0) {
                 hK[k] -= a;
@@ -355,7 +355,7 @@
                     final double c = householderVectors[i][k];
                     xNormSqr += c * c;
                 }
-                final double b = (hKp1[k] > 0) ? -AccurateMath.sqrt(xNormSqr) : AccurateMath.sqrt(xNormSqr);
+                final double b = (hKp1[k] > 0) ? -JdkMath.sqrt(xNormSqr) : JdkMath.sqrt(xNormSqr);
                 secondary[k] = b;
                 if (b != 0.0) {
                     hKp1[k] -= b;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/BlockFieldMatrix.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/BlockFieldMatrix.java
index 3caf51e..7c83802 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/BlockFieldMatrix.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/BlockFieldMatrix.java
@@ -28,7 +28,7 @@
 import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 
 /**
@@ -224,11 +224,11 @@
         int blockIndex = 0;
         for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
             final int pStart  = iBlock * BLOCK_SIZE;
-            final int pEnd    = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd    = JdkMath.min(pStart + BLOCK_SIZE, rows);
             final int iHeight = pEnd - pStart;
             for (int jBlock = 0; jBlock < blockColumns; ++jBlock) {
                 final int qStart = jBlock * BLOCK_SIZE;
-                final int qEnd   = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+                final int qEnd   = JdkMath.min(qStart + BLOCK_SIZE, columns);
                 final int jWidth = qEnd - qStart;
 
                 // allocate new block
@@ -273,11 +273,11 @@
         int blockIndex = 0;
         for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
             final int pStart  = iBlock * BLOCK_SIZE;
-            final int pEnd    = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd    = JdkMath.min(pStart + BLOCK_SIZE, rows);
             final int iHeight = pEnd - pStart;
             for (int jBlock = 0; jBlock < blockColumns; ++jBlock) {
                 final int qStart = jBlock * BLOCK_SIZE;
-                final int qEnd   = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+                final int qEnd   = JdkMath.min(qStart + BLOCK_SIZE, columns);
                 final int jWidth = qEnd - qStart;
                 blocks[blockIndex] = MathArrays.buildArray(field, iHeight * jWidth);
                 ++blockIndex;
@@ -333,9 +333,9 @@
                 final T[] outBlock = out.blocks[blockIndex];
                 final T[] tBlock   = blocks[blockIndex];
                 final int      pStart   = iBlock * BLOCK_SIZE;
-                final int      pEnd     = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+                final int      pEnd     = JdkMath.min(pStart + BLOCK_SIZE, rows);
                 final int      qStart   = jBlock * BLOCK_SIZE;
-                final int      qEnd     = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+                final int      qEnd     = JdkMath.min(qStart + BLOCK_SIZE, columns);
                 int k = 0;
                 for (int p = pStart; p < pEnd; ++p) {
                     for (int q = qStart; q < qEnd; ++q) {
@@ -404,9 +404,9 @@
                 final T[] outBlock = out.blocks[blockIndex];
                 final T[] tBlock   = blocks[blockIndex];
                 final int      pStart   = iBlock * BLOCK_SIZE;
-                final int      pEnd     = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+                final int      pEnd     = JdkMath.min(pStart + BLOCK_SIZE, rows);
                 final int      qStart   = jBlock * BLOCK_SIZE;
-                final int      qEnd     = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+                final int      qEnd     = JdkMath.min(qStart + BLOCK_SIZE, columns);
                 int k = 0;
                 for (int p = pStart; p < pEnd; ++p) {
                     for (int q = qStart; q < qEnd; ++q) {
@@ -505,12 +505,12 @@
         for (int iBlock = 0; iBlock < out.blockRows; ++iBlock) {
 
             final int pStart = iBlock * BLOCK_SIZE;
-            final int pEnd   = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd   = JdkMath.min(pStart + BLOCK_SIZE, rows);
 
             for (int jBlock = 0; jBlock < out.blockColumns; ++jBlock) {
 
                 final int qStart = jBlock * BLOCK_SIZE;
-                final int qEnd   = AccurateMath.min(qStart + BLOCK_SIZE, m.getColumnDimension());
+                final int qEnd   = JdkMath.min(qStart + BLOCK_SIZE, m.getColumnDimension());
 
                 // select current block
                 final T[] outBlock = out.blocks[blockIndex];
@@ -567,7 +567,7 @@
         for (int iBlock = 0; iBlock < out.blockRows; ++iBlock) {
 
             final int pStart = iBlock * BLOCK_SIZE;
-            final int pEnd   = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd   = JdkMath.min(pStart + BLOCK_SIZE, rows);
 
             for (int jBlock = 0; jBlock < out.blockColumns; ++jBlock) {
                 final int jWidth = out.blockWidth(jBlock);
@@ -627,7 +627,7 @@
 
         for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
             final int pStart = iBlock * BLOCK_SIZE;
-            final int pEnd   = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd   = JdkMath.min(pStart + BLOCK_SIZE, rows);
             int regularPos   = 0;
             int lastPos      = 0;
             for (int p = pStart; p < pEnd; ++p) {
@@ -804,14 +804,14 @@
         for (int iBlock = blockStartRow; iBlock < blockEndRow; ++iBlock) {
             final int iHeight  = blockHeight(iBlock);
             final int firstRow = iBlock * BLOCK_SIZE;
-            final int iStart   = AccurateMath.max(row,    firstRow);
-            final int iEnd     = AccurateMath.min(endRow + 1, firstRow + iHeight);
+            final int iStart   = JdkMath.max(row,    firstRow);
+            final int iEnd     = JdkMath.min(endRow + 1, firstRow + iHeight);
 
             for (int jBlock = blockStartColumn; jBlock < blockEndColumn; ++jBlock) {
                 final int jWidth      = blockWidth(jBlock);
                 final int firstColumn = jBlock * BLOCK_SIZE;
-                final int jStart      = AccurateMath.max(column,    firstColumn);
-                final int jEnd        = AccurateMath.min(endColumn + 1, firstColumn + jWidth);
+                final int jStart      = JdkMath.max(column,    firstColumn);
+                final int jEnd        = JdkMath.min(endColumn + 1, firstColumn + jWidth);
                 final int jLength     = jEnd - jStart;
 
                 // handle one block, row by row
@@ -1226,9 +1226,9 @@
                 final T[] outBlock = out.blocks[blockIndex];
                 final T[] tBlock   = blocks[jBlock * blockColumns + iBlock];
                 final int      pStart   = iBlock * BLOCK_SIZE;
-                final int      pEnd     = AccurateMath.min(pStart + BLOCK_SIZE, columns);
+                final int      pEnd     = JdkMath.min(pStart + BLOCK_SIZE, columns);
                 final int      qStart   = jBlock * BLOCK_SIZE;
-                final int      qEnd     = AccurateMath.min(qStart + BLOCK_SIZE, rows);
+                final int      qEnd     = JdkMath.min(qStart + BLOCK_SIZE, rows);
                 int k = 0;
                 for (int p = pStart; p < pEnd; ++p) {
                     final int lInc = pEnd - pStart;
@@ -1273,11 +1273,11 @@
         // perform multiplication block-wise, to ensure good cache behavior
         for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
             final int pStart = iBlock * BLOCK_SIZE;
-            final int pEnd   = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd   = JdkMath.min(pStart + BLOCK_SIZE, rows);
             for (int jBlock = 0; jBlock < blockColumns; ++jBlock) {
                 final T[] block  = blocks[iBlock * blockColumns + jBlock];
                 final int      qStart = jBlock * BLOCK_SIZE;
-                final int      qEnd   = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+                final int      qEnd   = JdkMath.min(qStart + BLOCK_SIZE, columns);
                 int k = 0;
                 for (int p = pStart; p < pEnd; ++p) {
                     T sum = zero;
@@ -1319,11 +1319,11 @@
             final int jWidth3 = jWidth2 + jWidth;
             final int jWidth4 = jWidth3 + jWidth;
             final int qStart = jBlock * BLOCK_SIZE;
-            final int qEnd   = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+            final int qEnd   = JdkMath.min(qStart + BLOCK_SIZE, columns);
             for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
                 final T[] block  = blocks[iBlock * blockColumns + jBlock];
                 final int      pStart = iBlock * BLOCK_SIZE;
-                final int      pEnd   = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+                final int      pEnd   = JdkMath.min(pStart + BLOCK_SIZE, rows);
                 for (int q = qStart; q < qEnd; ++q) {
                     int k = q - qStart;
                     T sum = zero;
@@ -1355,12 +1355,12 @@
         visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);
         for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
             final int pStart = iBlock * BLOCK_SIZE;
-            final int pEnd   = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd   = JdkMath.min(pStart + BLOCK_SIZE, rows);
             for (int p = pStart; p < pEnd; ++p) {
                 for (int jBlock = 0; jBlock < blockColumns; ++jBlock) {
                     final int jWidth = blockWidth(jBlock);
                     final int qStart = jBlock * BLOCK_SIZE;
-                    final int qEnd   = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+                    final int qEnd   = JdkMath.min(qStart + BLOCK_SIZE, columns);
                     final T[] block = blocks[iBlock * blockColumns + jBlock];
                     int k = (p - pStart) * jWidth;
                     for (int q = qStart; q < qEnd; ++q) {
@@ -1379,12 +1379,12 @@
         visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);
         for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
             final int pStart = iBlock * BLOCK_SIZE;
-            final int pEnd   = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd   = JdkMath.min(pStart + BLOCK_SIZE, rows);
             for (int p = pStart; p < pEnd; ++p) {
                 for (int jBlock = 0; jBlock < blockColumns; ++jBlock) {
                     final int jWidth = blockWidth(jBlock);
                     final int qStart = jBlock * BLOCK_SIZE;
-                    final int qEnd   = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+                    final int qEnd   = JdkMath.min(qStart + BLOCK_SIZE, columns);
                     final T[] block = blocks[iBlock * blockColumns + jBlock];
                     int k = (p - pStart) * jWidth;
                     for (int q = qStart; q < qEnd; ++q) {
@@ -1407,14 +1407,14 @@
         visitor.start(rows, columns, startRow, endRow, startColumn, endColumn);
         for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) {
             final int p0     = iBlock * BLOCK_SIZE;
-            final int pStart = AccurateMath.max(startRow, p0);
-            final int pEnd   = AccurateMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow);
+            final int pStart = JdkMath.max(startRow, p0);
+            final int pEnd   = JdkMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow);
             for (int p = pStart; p < pEnd; ++p) {
                 for (int jBlock = startColumn / BLOCK_SIZE; jBlock < 1 + endColumn / BLOCK_SIZE; ++jBlock) {
                     final int jWidth = blockWidth(jBlock);
                     final int q0     = jBlock * BLOCK_SIZE;
-                    final int qStart = AccurateMath.max(startColumn, q0);
-                    final int qEnd   = AccurateMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn);
+                    final int qStart = JdkMath.max(startColumn, q0);
+                    final int qEnd   = JdkMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn);
                     final T[] block = blocks[iBlock * blockColumns + jBlock];
                     int k = (p - p0) * jWidth + qStart - q0;
                     for (int q = qStart; q < qEnd; ++q) {
@@ -1437,14 +1437,14 @@
         visitor.start(rows, columns, startRow, endRow, startColumn, endColumn);
         for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) {
             final int p0     = iBlock * BLOCK_SIZE;
-            final int pStart = AccurateMath.max(startRow, p0);
-            final int pEnd   = AccurateMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow);
+            final int pStart = JdkMath.max(startRow, p0);
+            final int pEnd   = JdkMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow);
             for (int p = pStart; p < pEnd; ++p) {
                 for (int jBlock = startColumn / BLOCK_SIZE; jBlock < 1 + endColumn / BLOCK_SIZE; ++jBlock) {
                     final int jWidth = blockWidth(jBlock);
                     final int q0     = jBlock * BLOCK_SIZE;
-                    final int qStart = AccurateMath.max(startColumn, q0);
-                    final int qEnd   = AccurateMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn);
+                    final int qStart = JdkMath.max(startColumn, q0);
+                    final int qEnd   = JdkMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn);
                     final T[] block = blocks[iBlock * blockColumns + jBlock];
                     int k = (p - p0) * jWidth + qStart - q0;
                     for (int q = qStart; q < qEnd; ++q) {
@@ -1464,10 +1464,10 @@
         int blockIndex = 0;
         for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
             final int pStart = iBlock * BLOCK_SIZE;
-            final int pEnd   = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd   = JdkMath.min(pStart + BLOCK_SIZE, rows);
             for (int jBlock = 0; jBlock < blockColumns; ++jBlock) {
                 final int qStart = jBlock * BLOCK_SIZE;
-                final int qEnd   = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+                final int qEnd   = JdkMath.min(qStart + BLOCK_SIZE, columns);
                 final T[] block = blocks[blockIndex];
                 int k = 0;
                 for (int p = pStart; p < pEnd; ++p) {
@@ -1489,10 +1489,10 @@
         int blockIndex = 0;
         for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
             final int pStart = iBlock * BLOCK_SIZE;
-            final int pEnd   = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd   = JdkMath.min(pStart + BLOCK_SIZE, rows);
             for (int jBlock = 0; jBlock < blockColumns; ++jBlock) {
                 final int qStart = jBlock * BLOCK_SIZE;
-                final int qEnd   = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+                final int qEnd   = JdkMath.min(qStart + BLOCK_SIZE, columns);
                 final T[] block = blocks[blockIndex];
                 int k = 0;
                 for (int p = pStart; p < pEnd; ++p) {
@@ -1517,13 +1517,13 @@
         visitor.start(rows, columns, startRow, endRow, startColumn, endColumn);
         for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) {
             final int p0     = iBlock * BLOCK_SIZE;
-            final int pStart = AccurateMath.max(startRow, p0);
-            final int pEnd   = AccurateMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow);
+            final int pStart = JdkMath.max(startRow, p0);
+            final int pEnd   = JdkMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow);
             for (int jBlock = startColumn / BLOCK_SIZE; jBlock < 1 + endColumn / BLOCK_SIZE; ++jBlock) {
                 final int jWidth = blockWidth(jBlock);
                 final int q0     = jBlock * BLOCK_SIZE;
-                final int qStart = AccurateMath.max(startColumn, q0);
-                final int qEnd   = AccurateMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn);
+                final int qStart = JdkMath.max(startColumn, q0);
+                final int qEnd   = JdkMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn);
                 final T[] block = blocks[iBlock * blockColumns + jBlock];
                 for (int p = pStart; p < pEnd; ++p) {
                     int k = (p - p0) * jWidth + qStart - q0;
@@ -1547,13 +1547,13 @@
         visitor.start(rows, columns, startRow, endRow, startColumn, endColumn);
         for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) {
             final int p0     = iBlock * BLOCK_SIZE;
-            final int pStart = AccurateMath.max(startRow, p0);
-            final int pEnd   = AccurateMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow);
+            final int pStart = JdkMath.max(startRow, p0);
+            final int pEnd   = JdkMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow);
             for (int jBlock = startColumn / BLOCK_SIZE; jBlock < 1 + endColumn / BLOCK_SIZE; ++jBlock) {
                 final int jWidth = blockWidth(jBlock);
                 final int q0     = jBlock * BLOCK_SIZE;
-                final int qStart = AccurateMath.max(startColumn, q0);
-                final int qEnd   = AccurateMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn);
+                final int qStart = JdkMath.max(startColumn, q0);
+                final int qEnd   = JdkMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn);
                 final T[] block = blocks[iBlock * blockColumns + jBlock];
                 for (int p = pStart; p < pEnd; ++p) {
                     int k = (p - p0) * jWidth + qStart - q0;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/BlockRealMatrix.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/BlockRealMatrix.java
index 7c63518..a9c50d1 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/BlockRealMatrix.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/BlockRealMatrix.java
@@ -27,7 +27,7 @@
 import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Cache-friendly implementation of RealMatrix using a flat arrays to store
@@ -215,11 +215,11 @@
         int blockIndex = 0;
         for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
             final int pStart = iBlock * BLOCK_SIZE;
-            final int pEnd = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd = JdkMath.min(pStart + BLOCK_SIZE, rows);
             final int iHeight = pEnd - pStart;
             for (int jBlock = 0; jBlock < blockColumns; ++jBlock) {
                 final int qStart = jBlock * BLOCK_SIZE;
-                final int qEnd = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+                final int qEnd = JdkMath.min(qStart + BLOCK_SIZE, columns);
                 final int jWidth = qEnd - qStart;
 
                 // allocate new block
@@ -259,11 +259,11 @@
         int blockIndex = 0;
         for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
             final int pStart = iBlock * BLOCK_SIZE;
-            final int pEnd = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd = JdkMath.min(pStart + BLOCK_SIZE, rows);
             final int iHeight = pEnd - pStart;
             for (int jBlock = 0; jBlock < blockColumns; ++jBlock) {
                 final int qStart = jBlock * BLOCK_SIZE;
-                final int qEnd = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+                final int qEnd = JdkMath.min(qStart + BLOCK_SIZE, columns);
                 final int jWidth = qEnd - qStart;
                 blocks[blockIndex] = new double[iHeight * jWidth];
                 ++blockIndex;
@@ -317,9 +317,9 @@
                 final double[] outBlock = out.blocks[blockIndex];
                 final double[] tBlock   = blocks[blockIndex];
                 final int pStart = iBlock * BLOCK_SIZE;
-                final int pEnd = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+                final int pEnd = JdkMath.min(pStart + BLOCK_SIZE, rows);
                 final int qStart = jBlock * BLOCK_SIZE;
-                final int qEnd = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+                final int qEnd = JdkMath.min(qStart + BLOCK_SIZE, columns);
                 int k = 0;
                 for (int p = pStart; p < pEnd; ++p) {
                     for (int q = qStart; q < qEnd; ++q) {
@@ -385,9 +385,9 @@
                 final double[] outBlock = out.blocks[blockIndex];
                 final double[] tBlock = blocks[blockIndex];
                 final int pStart = iBlock * BLOCK_SIZE;
-                final int pEnd = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+                final int pEnd = JdkMath.min(pStart + BLOCK_SIZE, rows);
                 final int qStart = jBlock * BLOCK_SIZE;
-                final int qEnd = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+                final int qEnd = JdkMath.min(qStart + BLOCK_SIZE, columns);
                 int k = 0;
                 for (int p = pStart; p < pEnd; ++p) {
                     for (int q = qStart; q < qEnd; ++q) {
@@ -483,11 +483,11 @@
         int blockIndex = 0;
         for (int iBlock = 0; iBlock < out.blockRows; ++iBlock) {
             final int pStart = iBlock * BLOCK_SIZE;
-            final int pEnd = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd = JdkMath.min(pStart + BLOCK_SIZE, rows);
 
             for (int jBlock = 0; jBlock < out.blockColumns; ++jBlock) {
                 final int qStart = jBlock * BLOCK_SIZE;
-                final int qEnd = AccurateMath.min(qStart + BLOCK_SIZE, m.getColumnDimension());
+                final int qEnd = JdkMath.min(qStart + BLOCK_SIZE, m.getColumnDimension());
 
                 // select current block
                 final double[] outBlock = out.blocks[blockIndex];
@@ -540,7 +540,7 @@
         for (int iBlock = 0; iBlock < out.blockRows; ++iBlock) {
 
             final int pStart = iBlock * BLOCK_SIZE;
-            final int pEnd = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd = JdkMath.min(pStart + BLOCK_SIZE, rows);
 
             for (int jBlock = 0; jBlock < out.blockColumns; ++jBlock) {
                 final int jWidth = out.blockWidth(jBlock);
@@ -597,7 +597,7 @@
 
         for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
             final int pStart = iBlock * BLOCK_SIZE;
-            final int pEnd = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd = JdkMath.min(pStart + BLOCK_SIZE, rows);
             int regularPos = 0;
             int lastPos = 0;
             for (int p = pStart; p < pEnd; ++p) {
@@ -631,13 +631,13 @@
                 for (int j = 0; j < jWidth; ++j) {
                     double sum = 0;
                     for (int i = 0; i < iHeight; ++i) {
-                        sum += AccurateMath.abs(block[i * jWidth + j]);
+                        sum += JdkMath.abs(block[i * jWidth + j]);
                     }
                     colSums[j] += sum;
                 }
             }
             for (int j = 0; j < jWidth; ++j) {
-                maxColSum = AccurateMath.max(maxColSum, colSums[j]);
+                maxColSum = JdkMath.max(maxColSum, colSums[j]);
             }
         }
         return maxColSum;
@@ -652,7 +652,7 @@
                 sum2 += entry * entry;
             }
         }
-        return AccurateMath.sqrt(sum2);
+        return JdkMath.sqrt(sum2);
     }
 
     /** {@inheritDoc} */
@@ -812,14 +812,14 @@
         for (int iBlock = blockStartRow; iBlock < blockEndRow; ++iBlock) {
             final int iHeight = blockHeight(iBlock);
             final int firstRow = iBlock * BLOCK_SIZE;
-            final int iStart = AccurateMath.max(row,    firstRow);
-            final int iEnd = AccurateMath.min(endRow + 1, firstRow + iHeight);
+            final int iStart = JdkMath.max(row,    firstRow);
+            final int iEnd = JdkMath.min(endRow + 1, firstRow + iHeight);
 
             for (int jBlock = blockStartColumn; jBlock < blockEndColumn; ++jBlock) {
                 final int jWidth = blockWidth(jBlock);
                 final int firstColumn = jBlock * BLOCK_SIZE;
-                final int jStart = AccurateMath.max(column,    firstColumn);
-                final int jEnd = AccurateMath.min(endColumn + 1, firstColumn + jWidth);
+                final int jStart = JdkMath.max(column,    firstColumn);
+                final int jEnd = JdkMath.min(endColumn + 1, firstColumn + jWidth);
                 final int jLength = jEnd - jStart;
 
                 // handle one block, row by row
@@ -1221,9 +1221,9 @@
                 final double[] outBlock = out.blocks[blockIndex];
                 final double[] tBlock = blocks[jBlock * blockColumns + iBlock];
                 final int pStart = iBlock * BLOCK_SIZE;
-                final int pEnd = AccurateMath.min(pStart + BLOCK_SIZE, columns);
+                final int pEnd = JdkMath.min(pStart + BLOCK_SIZE, columns);
                 final int qStart = jBlock * BLOCK_SIZE;
-                final int qEnd = AccurateMath.min(qStart + BLOCK_SIZE, rows);
+                final int qEnd = JdkMath.min(qStart + BLOCK_SIZE, rows);
                 int k = 0;
                 for (int p = pStart; p < pEnd; ++p) {
                     final int lInc = pEnd - pStart;
@@ -1266,11 +1266,11 @@
         // perform multiplication block-wise, to ensure good cache behavior
         for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
             final int pStart = iBlock * BLOCK_SIZE;
-            final int pEnd = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd = JdkMath.min(pStart + BLOCK_SIZE, rows);
             for (int jBlock = 0; jBlock < blockColumns; ++jBlock) {
                 final double[] block  = blocks[iBlock * blockColumns + jBlock];
                 final int qStart = jBlock * BLOCK_SIZE;
-                final int qEnd = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+                final int qEnd = JdkMath.min(qStart + BLOCK_SIZE, columns);
                 int k = 0;
                 for (int p = pStart; p < pEnd; ++p) {
                     double sum = 0;
@@ -1310,11 +1310,11 @@
             final int jWidth3 = jWidth2 + jWidth;
             final int jWidth4 = jWidth3 + jWidth;
             final int qStart = jBlock * BLOCK_SIZE;
-            final int qEnd = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+            final int qEnd = JdkMath.min(qStart + BLOCK_SIZE, columns);
             for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
                 final double[] block  = blocks[iBlock * blockColumns + jBlock];
                 final int pStart = iBlock * BLOCK_SIZE;
-                final int pEnd = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+                final int pEnd = JdkMath.min(pStart + BLOCK_SIZE, rows);
                 for (int q = qStart; q < qEnd; ++q) {
                     int k = q - qStart;
                     double sum = 0;
@@ -1345,12 +1345,12 @@
         visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);
         for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
             final int pStart = iBlock * BLOCK_SIZE;
-            final int pEnd = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd = JdkMath.min(pStart + BLOCK_SIZE, rows);
             for (int p = pStart; p < pEnd; ++p) {
                 for (int jBlock = 0; jBlock < blockColumns; ++jBlock) {
                     final int jWidth = blockWidth(jBlock);
                     final int qStart = jBlock * BLOCK_SIZE;
-                    final int qEnd = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+                    final int qEnd = JdkMath.min(qStart + BLOCK_SIZE, columns);
                     final double[] block = blocks[iBlock * blockColumns + jBlock];
                     int k = (p - pStart) * jWidth;
                     for (int q = qStart; q < qEnd; ++q) {
@@ -1369,12 +1369,12 @@
         visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);
         for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
             final int pStart = iBlock * BLOCK_SIZE;
-            final int pEnd = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd = JdkMath.min(pStart + BLOCK_SIZE, rows);
             for (int p = pStart; p < pEnd; ++p) {
                 for (int jBlock = 0; jBlock < blockColumns; ++jBlock) {
                     final int jWidth = blockWidth(jBlock);
                     final int qStart = jBlock * BLOCK_SIZE;
-                    final int qEnd = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+                    final int qEnd = JdkMath.min(qStart + BLOCK_SIZE, columns);
                     final double[] block = blocks[iBlock * blockColumns + jBlock];
                     int k = (p - pStart) * jWidth;
                     for (int q = qStart; q < qEnd; ++q) {
@@ -1397,14 +1397,14 @@
         visitor.start(rows, columns, startRow, endRow, startColumn, endColumn);
         for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) {
             final int p0 = iBlock * BLOCK_SIZE;
-            final int pStart = AccurateMath.max(startRow, p0);
-            final int pEnd = AccurateMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow);
+            final int pStart = JdkMath.max(startRow, p0);
+            final int pEnd = JdkMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow);
             for (int p = pStart; p < pEnd; ++p) {
                 for (int jBlock = startColumn / BLOCK_SIZE; jBlock < 1 + endColumn / BLOCK_SIZE; ++jBlock) {
                     final int jWidth = blockWidth(jBlock);
                     final int q0 = jBlock * BLOCK_SIZE;
-                    final int qStart = AccurateMath.max(startColumn, q0);
-                    final int qEnd = AccurateMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn);
+                    final int qStart = JdkMath.max(startColumn, q0);
+                    final int qEnd = JdkMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn);
                     final double[] block = blocks[iBlock * blockColumns + jBlock];
                     int k = (p - p0) * jWidth + qStart - q0;
                     for (int q = qStart; q < qEnd; ++q) {
@@ -1427,14 +1427,14 @@
         visitor.start(rows, columns, startRow, endRow, startColumn, endColumn);
         for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) {
             final int p0 = iBlock * BLOCK_SIZE;
-            final int pStart = AccurateMath.max(startRow, p0);
-            final int pEnd = AccurateMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow);
+            final int pStart = JdkMath.max(startRow, p0);
+            final int pEnd = JdkMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow);
             for (int p = pStart; p < pEnd; ++p) {
                 for (int jBlock = startColumn / BLOCK_SIZE; jBlock < 1 + endColumn / BLOCK_SIZE; ++jBlock) {
                     final int jWidth = blockWidth(jBlock);
                     final int q0 = jBlock * BLOCK_SIZE;
-                    final int qStart = AccurateMath.max(startColumn, q0);
-                    final int qEnd = AccurateMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn);
+                    final int qStart = JdkMath.max(startColumn, q0);
+                    final int qEnd = JdkMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn);
                     final double[] block = blocks[iBlock * blockColumns + jBlock];
                     int k = (p - p0) * jWidth + qStart - q0;
                     for (int q = qStart; q < qEnd; ++q) {
@@ -1454,10 +1454,10 @@
         int blockIndex = 0;
         for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
             final int pStart = iBlock * BLOCK_SIZE;
-            final int pEnd = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd = JdkMath.min(pStart + BLOCK_SIZE, rows);
             for (int jBlock = 0; jBlock < blockColumns; ++jBlock) {
                 final int qStart = jBlock * BLOCK_SIZE;
-                final int qEnd = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+                final int qEnd = JdkMath.min(qStart + BLOCK_SIZE, columns);
                 final double[] block = blocks[blockIndex];
                 int k = 0;
                 for (int p = pStart; p < pEnd; ++p) {
@@ -1479,10 +1479,10 @@
         int blockIndex = 0;
         for (int iBlock = 0; iBlock < blockRows; ++iBlock) {
             final int pStart = iBlock * BLOCK_SIZE;
-            final int pEnd = AccurateMath.min(pStart + BLOCK_SIZE, rows);
+            final int pEnd = JdkMath.min(pStart + BLOCK_SIZE, rows);
             for (int jBlock = 0; jBlock < blockColumns; ++jBlock) {
                 final int qStart = jBlock * BLOCK_SIZE;
-                final int qEnd = AccurateMath.min(qStart + BLOCK_SIZE, columns);
+                final int qEnd = JdkMath.min(qStart + BLOCK_SIZE, columns);
                 final double[] block = blocks[blockIndex];
                 int k = 0;
                 for (int p = pStart; p < pEnd; ++p) {
@@ -1508,13 +1508,13 @@
         visitor.start(rows, columns, startRow, endRow, startColumn, endColumn);
         for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) {
             final int p0 = iBlock * BLOCK_SIZE;
-            final int pStart = AccurateMath.max(startRow, p0);
-            final int pEnd = AccurateMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow);
+            final int pStart = JdkMath.max(startRow, p0);
+            final int pEnd = JdkMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow);
             for (int jBlock = startColumn / BLOCK_SIZE; jBlock < 1 + endColumn / BLOCK_SIZE; ++jBlock) {
                 final int jWidth = blockWidth(jBlock);
                 final int q0 = jBlock * BLOCK_SIZE;
-                final int qStart = AccurateMath.max(startColumn, q0);
-                final int qEnd = AccurateMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn);
+                final int qStart = JdkMath.max(startColumn, q0);
+                final int qEnd = JdkMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn);
                 final double[] block = blocks[iBlock * blockColumns + jBlock];
                 for (int p = pStart; p < pEnd; ++p) {
                     int k = (p - p0) * jWidth + qStart - q0;
@@ -1539,13 +1539,13 @@
         visitor.start(rows, columns, startRow, endRow, startColumn, endColumn);
         for (int iBlock = startRow / BLOCK_SIZE; iBlock < 1 + endRow / BLOCK_SIZE; ++iBlock) {
             final int p0 = iBlock * BLOCK_SIZE;
-            final int pStart = AccurateMath.max(startRow, p0);
-            final int pEnd = AccurateMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow);
+            final int pStart = JdkMath.max(startRow, p0);
+            final int pEnd = JdkMath.min((iBlock + 1) * BLOCK_SIZE, 1 + endRow);
             for (int jBlock = startColumn / BLOCK_SIZE; jBlock < 1 + endColumn / BLOCK_SIZE; ++jBlock) {
                 final int jWidth = blockWidth(jBlock);
                 final int q0 = jBlock * BLOCK_SIZE;
-                final int qStart = AccurateMath.max(startColumn, q0);
-                final int qEnd = AccurateMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn);
+                final int qStart = JdkMath.max(startColumn, q0);
+                final int qEnd = JdkMath.min((jBlock + 1) * BLOCK_SIZE, 1 + endColumn);
                 final double[] block = blocks[iBlock * blockColumns + jBlock];
                 for (int p = pStart; p < pEnd; ++p) {
                     int k = (p - p0) * jWidth + qStart - q0;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/CholeskyDecomposition.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/CholeskyDecomposition.java
index 1ad6322..ef54331 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/CholeskyDecomposition.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/CholeskyDecomposition.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.linear;
 
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 
 /**
@@ -123,8 +123,8 @@
                 final double lIJ = lI[j];
                 final double lJI = lJ[i];
                 final double maxDelta =
-                    relativeSymmetryThreshold * AccurateMath.max(AccurateMath.abs(lIJ), AccurateMath.abs(lJI));
-                if (AccurateMath.abs(lIJ - lJI) > maxDelta) {
+                    relativeSymmetryThreshold * JdkMath.max(JdkMath.abs(lIJ), JdkMath.abs(lJI));
+                if (JdkMath.abs(lIJ - lJI) > maxDelta) {
                     throw new NonSymmetricMatrixException(i, j, relativeSymmetryThreshold);
                 }
                 lJ[i] = 0;
@@ -141,7 +141,7 @@
                 throw new NonPositiveDefiniteMatrixException(ltI[i], i, absolutePositivityThreshold);
             }
 
-            ltI[i] = AccurateMath.sqrt(ltI[i]);
+            ltI[i] = JdkMath.sqrt(ltI[i]);
             final double inverse = 1.0 / ltI[i];
 
             for (int q = order - 1; q > i; --q) {
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/DiagonalMatrix.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/DiagonalMatrix.java
index 4930691..ee705c8 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/DiagonalMatrix.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/DiagonalMatrix.java
@@ -23,7 +23,7 @@
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.numbers.core.Precision;
 
 /**
@@ -313,7 +313,7 @@
      */
     private void ensureZero(final double value) throws NumberIsTooLargeException {
         if (!Precision.equals(0.0, value, 1)) {
-            throw new NumberIsTooLargeException(AccurateMath.abs(value), 0, true);
+            throw new NumberIsTooLargeException(JdkMath.abs(value), 0, true);
         }
     }
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/EigenDecomposition.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/EigenDecomposition.java
index 1a07941..5e8b086 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/EigenDecomposition.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/EigenDecomposition.java
@@ -24,7 +24,7 @@
 import org.apache.commons.math4.legacy.exception.MathUnsupportedOperationException;
 import org.apache.commons.math4.legacy.exception.MaxCountExceededException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Calculates the eigen decomposition of a real matrix.
@@ -349,7 +349,7 @@
             if (eigen <= 0) {
                 throw new MathUnsupportedOperationException();
             }
-            sqrtEigenValues[i] = AccurateMath.sqrt(eigen);
+            sqrtEigenValues[i] = JdkMath.sqrt(eigen);
         }
         final RealMatrix sqrtEigen = MatrixUtils.createRealDiagonalMatrix(sqrtEigenValues);
         final RealMatrix v = getV();
@@ -487,7 +487,7 @@
             // Looping over all values (in case they are not sorted in decreasing
             // order of their norm).
             for (int i = 0; i < realEigenvalues.length; ++i) {
-                largestEigenvalueNorm = AccurateMath.max(largestEigenvalueNorm, eigenvalueNorm(i));
+                largestEigenvalueNorm = JdkMath.max(largestEigenvalueNorm, eigenvalueNorm(i));
             }
             // Corner case: zero matrix, all exactly 0 eigenvalues
             if (largestEigenvalueNorm == 0.0) {
@@ -510,7 +510,7 @@
         private double eigenvalueNorm(int i) {
             final double re = realEigenvalues[i];
             final double im = imagEigenvalues[i];
-            return AccurateMath.sqrt(re * re + im * im);
+            return JdkMath.sqrt(re * re + im * im);
         }
 
         /**
@@ -577,20 +577,20 @@
         // Determine the largest main and secondary value in absolute term.
         double maxAbsoluteValue = 0;
         for (int i = 0; i < n; i++) {
-            if (AccurateMath.abs(realEigenvalues[i]) > maxAbsoluteValue) {
-                maxAbsoluteValue = AccurateMath.abs(realEigenvalues[i]);
+            if (JdkMath.abs(realEigenvalues[i]) > maxAbsoluteValue) {
+                maxAbsoluteValue = JdkMath.abs(realEigenvalues[i]);
             }
-            if (AccurateMath.abs(e[i]) > maxAbsoluteValue) {
-                maxAbsoluteValue = AccurateMath.abs(e[i]);
+            if (JdkMath.abs(e[i]) > maxAbsoluteValue) {
+                maxAbsoluteValue = JdkMath.abs(e[i]);
             }
         }
         // Make null any main and secondary value too small to be significant
         if (maxAbsoluteValue != 0) {
             for (int i=0; i < n; i++) {
-                if (AccurateMath.abs(realEigenvalues[i]) <= Precision.EPSILON * maxAbsoluteValue) {
+                if (JdkMath.abs(realEigenvalues[i]) <= Precision.EPSILON * maxAbsoluteValue) {
                     realEigenvalues[i] = 0;
                 }
-                if (AccurateMath.abs(e[i]) <= Precision.EPSILON * maxAbsoluteValue) {
+                if (JdkMath.abs(e[i]) <= Precision.EPSILON * maxAbsoluteValue) {
                     e[i]=0;
                 }
             }
@@ -601,9 +601,9 @@
             int m;
             do {
                 for (m = j; m < n - 1; m++) {
-                    double delta = AccurateMath.abs(realEigenvalues[m]) +
-                        AccurateMath.abs(realEigenvalues[m + 1]);
-                    if (AccurateMath.abs(e[m]) + delta == delta) {
+                    double delta = JdkMath.abs(realEigenvalues[m]) +
+                        JdkMath.abs(realEigenvalues[m + 1]);
+                    if (JdkMath.abs(e[m]) + delta == delta) {
                         break;
                     }
                 }
@@ -614,7 +614,7 @@
                     }
                     its++;
                     double q = (realEigenvalues[j + 1] - realEigenvalues[j]) / (2 * e[j]);
-                    double t = AccurateMath.sqrt(1 + q * q);
+                    double t = JdkMath.sqrt(1 + q * q);
                     if (q < 0.0) {
                         q = realEigenvalues[m] - realEigenvalues[j] + e[j] / (q - t);
                     } else {
@@ -627,15 +627,15 @@
                     for (i = m - 1; i >= j; i--) {
                         double p = s * e[i];
                         double h = c * e[i];
-                        if (AccurateMath.abs(p) >= AccurateMath.abs(q)) {
+                        if (JdkMath.abs(p) >= JdkMath.abs(q)) {
                             c = q / p;
-                            t = AccurateMath.sqrt(c * c + 1.0);
+                            t = JdkMath.sqrt(c * c + 1.0);
                             e[i + 1] = p * t;
                             s = 1.0 / t;
                             c *= s;
                         } else {
                             s = p / q;
-                            t = AccurateMath.sqrt(s * s + 1.0);
+                            t = JdkMath.sqrt(s * s + 1.0);
                             e[i + 1] = q * t;
                             c = 1.0 / t;
                             s *= c;
@@ -690,14 +690,14 @@
         // Determine the largest eigen value in absolute term.
         maxAbsoluteValue = 0;
         for (int i = 0; i < n; i++) {
-            if (AccurateMath.abs(realEigenvalues[i]) > maxAbsoluteValue) {
-                maxAbsoluteValue=AccurateMath.abs(realEigenvalues[i]);
+            if (JdkMath.abs(realEigenvalues[i]) > maxAbsoluteValue) {
+                maxAbsoluteValue=JdkMath.abs(realEigenvalues[i]);
             }
         }
         // Make null any eigen value too small to be significant
         if (maxAbsoluteValue != 0.0) {
             for (int i=0; i < n; i++) {
-                if (AccurateMath.abs(realEigenvalues[i]) < Precision.EPSILON * maxAbsoluteValue) {
+                if (JdkMath.abs(realEigenvalues[i]) < Precision.EPSILON * maxAbsoluteValue) {
                     realEigenvalues[i] = 0;
                 }
             }
@@ -732,7 +732,7 @@
             } else {
                 final double x = matT[i + 1][i + 1];
                 final double p = 0.5 * (matT[i][i] - x);
-                final double z = AccurateMath.sqrt(AccurateMath.abs(p * p + matT[i + 1][i] * matT[i][i + 1]));
+                final double z = JdkMath.sqrt(JdkMath.abs(p * p + matT[i + 1][i] * matT[i][i + 1]));
                 realEigenvalues[i] = x + p;
                 imagEigenvalues[i] = z;
                 realEigenvalues[i + 1] = x + p;
@@ -773,8 +773,8 @@
         // compute matrix norm
         double norm = 0.0;
         for (int i = 0; i < n; i++) {
-           for (int j = AccurateMath.max(i - 1, 0); j < n; j++) {
-               norm += AccurateMath.abs(matrixT[i][j]);
+           for (int j = JdkMath.max(i - 1, 0); j < n; j++) {
+               norm += JdkMath.abs(matrixT[i][j]);
            }
         }
 
@@ -822,7 +822,7 @@
                                 imagEigenvalues[i] * imagEigenvalues[i];
                             double t = (x * s - z * r) / q;
                             matrixT[i][idx] = t;
-                            if (AccurateMath.abs(x) > AccurateMath.abs(z)) {
+                            if (JdkMath.abs(x) > JdkMath.abs(z)) {
                                 matrixT[i + 1][idx] = (-r - w * t) / x;
                             } else {
                                 matrixT[i + 1][idx] = (-s - y * t) / z;
@@ -830,7 +830,7 @@
                         }
 
                         // Overflow control
-                        double t = AccurateMath.abs(matrixT[i][idx]);
+                        double t = JdkMath.abs(matrixT[i][idx]);
                         if ((Precision.EPSILON * t) * t > 1) {
                             for (int j = i; j <= idx; j++) {
                                 matrixT[j][idx] /= t;
@@ -843,7 +843,7 @@
                 int l = idx - 1;
 
                 // Last vector component imaginary so matrix is triangular
-                if (AccurateMath.abs(matrixT[idx][idx - 1]) > AccurateMath.abs(matrixT[idx - 1][idx])) {
+                if (JdkMath.abs(matrixT[idx][idx - 1]) > JdkMath.abs(matrixT[idx - 1][idx])) {
                     matrixT[idx - 1][idx - 1] = q / matrixT[idx][idx - 1];
                     matrixT[idx - 1][idx]     = -(matrixT[idx][idx] - p) / matrixT[idx][idx - 1];
                 } else {
@@ -884,15 +884,15 @@
                             final double vi = (realEigenvalues[i] - p) * 2.0 * q;
                             if (Precision.equals(vr, 0.0) && Precision.equals(vi, 0.0)) {
                                 vr = Precision.EPSILON * norm *
-                                     (AccurateMath.abs(w) + AccurateMath.abs(q) + AccurateMath.abs(x) +
-                                      AccurateMath.abs(y) + AccurateMath.abs(z));
+                                     (JdkMath.abs(w) + JdkMath.abs(q) + JdkMath.abs(x) +
+                                      JdkMath.abs(y) + JdkMath.abs(z));
                             }
                             final Complex c     = cdiv(x * r - z * ra + q * sa,
                                                        x * s - z * sa - q * ra, vr, vi);
                             matrixT[i][idx - 1] = c.getReal();
                             matrixT[i][idx]     = c.getImaginary();
 
-                            if (AccurateMath.abs(x) > (AccurateMath.abs(z) + AccurateMath.abs(q))) {
+                            if (JdkMath.abs(x) > (JdkMath.abs(z) + JdkMath.abs(q))) {
                                 matrixT[i + 1][idx - 1] = (-ra - w * matrixT[i][idx - 1] +
                                                            q * matrixT[i][idx]) / x;
                                 matrixT[i + 1][idx]     = (-sa - w * matrixT[i][idx] -
@@ -906,8 +906,8 @@
                         }
 
                         // Overflow control
-                        double t = AccurateMath.max(AccurateMath.abs(matrixT[i][idx - 1]),
-                                                AccurateMath.abs(matrixT[i][idx]));
+                        double t = JdkMath.max(JdkMath.abs(matrixT[i][idx - 1]),
+                                                JdkMath.abs(matrixT[i][idx]));
                         if ((Precision.EPSILON * t) * t > 1) {
                             for (int j = i; j <= idx; j++) {
                                 matrixT[j][idx - 1] /= t;
@@ -923,7 +923,7 @@
         for (int j = n - 1; j >= 0; j--) {
             for (int i = 0; i <= n - 1; i++) {
                 z = 0.0;
-                for (int k = 0; k <= AccurateMath.min(j, n - 1); k++) {
+                for (int k = 0; k <= JdkMath.min(j, n - 1); k++) {
                     z += matrixP[i][k] * matrixT[k][j];
                 }
                 matrixP[i][j] = z;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/HessenbergTransformer.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/HessenbergTransformer.java
index 240d731..3b7d9df 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/HessenbergTransformer.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/HessenbergTransformer.java
@@ -17,7 +17,7 @@
 
 package org.apache.commons.math4.legacy.linear;
 
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.numbers.core.Precision;
 
 /**
@@ -184,7 +184,7 @@
             // Scale column.
             double scale = 0;
             for (int i = m; i <= high; i++) {
-                scale += AccurateMath.abs(householderVectors[i][m - 1]);
+                scale += JdkMath.abs(householderVectors[i][m - 1]);
             }
 
             if (!Precision.equals(scale, 0)) {
@@ -194,7 +194,7 @@
                     ort[i] = householderVectors[i][m - 1] / scale;
                     h += ort[i] * ort[i];
                 }
-                final double g = (ort[m] > 0) ? -AccurateMath.sqrt(h) : AccurateMath.sqrt(h);
+                final double g = (ort[m] > 0) ? -JdkMath.sqrt(h) : JdkMath.sqrt(h);
 
                 h -= ort[m] * g;
                 ort[m] -= g;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/LUDecomposition.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/LUDecomposition.java
index 6cfa36f..f2e170a 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/LUDecomposition.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/LUDecomposition.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.linear;
 
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Calculates the LUP-decomposition of a square matrix.
@@ -127,14 +127,14 @@
                 luRow[col] = sum;
 
                 // maintain best permutation choice
-                if (AccurateMath.abs(sum) > largest) {
-                    largest = AccurateMath.abs(sum);
+                if (JdkMath.abs(sum) > largest) {
+                    largest = JdkMath.abs(sum);
                     max = row;
                 }
             }
 
             // Singularity check
-            if (AccurateMath.abs(lu[max][col]) < singularityThreshold) {
+            if (JdkMath.abs(lu[max][col]) < singularityThreshold) {
                 singular = true;
                 return;
             }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/MatrixUtils.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/MatrixUtils.java
index 7504cac..2c7dca5 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/MatrixUtils.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/MatrixUtils.java
@@ -32,7 +32,7 @@
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
 import org.apache.commons.math4.legacy.exception.ZeroException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 import org.apache.commons.numbers.core.Precision;
 
@@ -412,8 +412,8 @@
             for (int j = i + 1; j < rows; j++) {
                 final double mij = matrix.getEntry(i, j);
                 final double mji = matrix.getEntry(j, i);
-                if (AccurateMath.abs(mij - mji) >
-                    AccurateMath.max(AccurateMath.abs(mij), AccurateMath.abs(mji)) * relativeTolerance) {
+                if (JdkMath.abs(mij - mji) >
+                    JdkMath.max(JdkMath.abs(mij), JdkMath.abs(mji)) * relativeTolerance) {
                     if (raiseException) {
                         throw new NonSymmetricMatrixException(i, j, relativeTolerance);
                     } else {
@@ -845,7 +845,7 @@
         int rows = rm.getRowDimension();
         for( int i = 0 ; i < rows ; i++ ){
             double diag = rm.getEntry(i, i);
-            if( AccurateMath.abs(diag) < Precision.SAFE_MIN ){
+            if( JdkMath.abs(diag) < Precision.SAFE_MIN ){
                 throw new MathArithmeticException(LocalizedFormats.ZERO_DENOMINATOR);
             }
             double bi = b.getEntry(i)/diag;
@@ -890,7 +890,7 @@
         int rows = rm.getRowDimension();
         for( int i = rows-1 ; i >-1 ; i-- ){
             double diag = rm.getEntry(i, i);
-            if( AccurateMath.abs(diag) < Precision.SAFE_MIN ){
+            if( JdkMath.abs(diag) < Precision.SAFE_MIN ){
                 throw new MathArithmeticException(LocalizedFormats.ZERO_DENOMINATOR);
             }
             double bi = b.getEntry(i)/diag;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/OpenIntToDoubleHashMap.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/OpenIntToDoubleHashMap.java
index f17886c..ea98eeb 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/OpenIntToDoubleHashMap.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/OpenIntToDoubleHashMap.java
@@ -17,7 +17,7 @@
 
 package org.apache.commons.math4.legacy.linear;
 
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 import java.io.IOException;
 import java.io.ObjectInputStream;
@@ -151,7 +151,7 @@
         if (expectedSize == 0) {
             return 1;
         }
-        final int capacity   = (int) AccurateMath.ceil(expectedSize / LOAD_FACTOR);
+        final int capacity   = (int) JdkMath.ceil(expectedSize / LOAD_FACTOR);
         final int powerOfTwo = Integer.highestOneBit(capacity);
         if (powerOfTwo == capacity) {
             return capacity;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/OpenIntToFieldHashMap.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/OpenIntToFieldHashMap.java
index 2790370..2dc00dd 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/OpenIntToFieldHashMap.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/OpenIntToFieldHashMap.java
@@ -25,7 +25,7 @@
 
 import org.apache.commons.math4.legacy.core.Field;
 import org.apache.commons.math4.legacy.core.FieldElement;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Open addressed map from int to FieldElement.
@@ -163,7 +163,7 @@
         if (expectedSize == 0) {
             return 1;
         }
-        final int capacity   = (int) AccurateMath.ceil(expectedSize / LOAD_FACTOR);
+        final int capacity   = (int) JdkMath.ceil(expectedSize / LOAD_FACTOR);
         final int powerOfTwo = Integer.highestOneBit(capacity);
         if (powerOfTwo == capacity) {
             return capacity;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/OpenMapRealVector.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/OpenMapRealVector.java
index 4d4a55c..17da319 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/OpenMapRealVector.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/OpenMapRealVector.java
@@ -23,7 +23,7 @@
 import org.apache.commons.math4.legacy.exception.NotPositiveException;
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.linear.OpenIntToDoubleHashMap.Iterator;
 
 /**
@@ -225,7 +225,7 @@
      * @since 2.1
      */
     protected boolean isDefaultValue(double value) {
-        return AccurateMath.abs(value) < epsilon;
+        return JdkMath.abs(value) < epsilon;
     }
 
     /** {@inheritDoc} */
@@ -401,7 +401,7 @@
                 res += value * value;
             }
         }
-        return AccurateMath.sqrt(res);
+        return JdkMath.sqrt(res);
     }
 
     /** {@inheritDoc} */
@@ -439,7 +439,7 @@
         Iterator iter = entries.iterator();
         while (iter.hasNext()) {
             iter.advance();
-            double delta = AccurateMath.abs(iter.value() - v.getEntry(iter.key()));
+            double delta = JdkMath.abs(iter.value() - v.getEntry(iter.key()));
             max += delta;
         }
         iter = v.getEntries().iterator();
@@ -447,8 +447,8 @@
             iter.advance();
             int key = iter.key();
             if (!entries.containsKey(key)) {
-                double delta = AccurateMath.abs(iter.value());
-                max +=  AccurateMath.abs(delta);
+                double delta = JdkMath.abs(iter.value());
+                max +=  JdkMath.abs(delta);
             }
         }
         return max;
@@ -480,7 +480,7 @@
         Iterator iter = entries.iterator();
         while (iter.hasNext()) {
             iter.advance();
-            double delta = AccurateMath.abs(iter.value() - v.getEntry(iter.key()));
+            double delta = JdkMath.abs(iter.value() - v.getEntry(iter.key()));
             if (delta > max) {
                 max = delta;
             }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/QRDecomposition.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/QRDecomposition.java
index f7a493b..2097502 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/QRDecomposition.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/QRDecomposition.java
@@ -20,7 +20,7 @@
 import java.util.Arrays;
 
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
 
 
@@ -97,7 +97,7 @@
         final int m = matrix.getRowDimension();
         final int n = matrix.getColumnDimension();
         qrt = matrix.transpose().getData();
-        rDiag = new double[AccurateMath.min(m, n)];
+        rDiag = new double[JdkMath.min(m, n)];
         cachedQ  = null;
         cachedQT = null;
         cachedR  = null;
@@ -112,7 +112,7 @@
      * @since 3.2
      */
     protected void decompose(double[][] matrix) {
-        for (int minor = 0; minor < AccurateMath.min(matrix.length, matrix[0].length); minor++) {
+        for (int minor = 0; minor < JdkMath.min(matrix.length, matrix[0].length); minor++) {
             performHouseholderReflection(minor, matrix);
         }
     }
@@ -138,7 +138,7 @@
             final double c = qrtMinor[row];
             xNormSqr += c * c;
         }
-        final double a = (qrtMinor[minor] > 0) ? -AccurateMath.sqrt(xNormSqr) : AccurateMath.sqrt(xNormSqr);
+        final double a = (qrtMinor[minor] > 0) ? -JdkMath.sqrt(xNormSqr) : JdkMath.sqrt(xNormSqr);
         rDiag[minor] = a;
 
         if (a != 0.0) {
@@ -196,7 +196,7 @@
             final int m = qrt[0].length;
             double[][] ra = new double[m][n];
             // copy the diagonal from rDiag and the upper triangle of qr
-            for (int row = AccurateMath.min(m, n) - 1; row >= 0; row--) {
+            for (int row = JdkMath.min(m, n) - 1; row >= 0; row--) {
                 ra[row][row] = rDiag[row];
                 for (int col = row + 1; col < n; col++) {
                     ra[row][col] = qrt[col][row];
@@ -239,11 +239,11 @@
              * applying the Householder transformations Q_(m-1),Q_(m-2),...,Q1 in
              * succession to the result
              */
-            for (int minor = m - 1; minor >= AccurateMath.min(m, n); minor--) {
+            for (int minor = m - 1; minor >= JdkMath.min(m, n); minor--) {
                 qta[minor][minor] = 1.0d;
             }
 
-            for (int minor = AccurateMath.min(m, n)-1; minor >= 0; minor--){
+            for (int minor = JdkMath.min(m, n)-1; minor >= 0; minor--){
                 final double[] qrtMinor = qrt[minor];
                 qta[minor][minor] = 1.0d;
                 if (qrtMinor[minor] != 0.0) {
@@ -281,7 +281,7 @@
             final int m = qrt[0].length;
             double[][] ha = new double[m][n];
             for (int i = 0; i < m; ++i) {
-                for (int j = 0; j < AccurateMath.min(i + 1, n); ++j) {
+                for (int j = 0; j < JdkMath.min(i + 1, n); ++j) {
                     ha[i][j] = qrt[j][i] / -rDiag[j];
                 }
             }
@@ -357,7 +357,7 @@
             final double[] y = b.toArray();
 
             // apply Householder transforms to solve Q.y = b
-            for (int minor = 0; minor < AccurateMath.min(m, n); minor++) {
+            for (int minor = 0; minor < JdkMath.min(m, n); minor++) {
 
                 final double[] qrtMinor = qrt[minor];
                 double dotProduct = 0;
@@ -404,14 +404,14 @@
 
             for (int kBlock = 0; kBlock < cBlocks; ++kBlock) {
                 final int kStart = kBlock * blockSize;
-                final int kEnd   = AccurateMath.min(kStart + blockSize, columns);
+                final int kEnd   = JdkMath.min(kStart + blockSize, columns);
                 final int kWidth = kEnd - kStart;
 
                 // get the right hand side vector
                 b.copySubMatrix(0, m - 1, kStart, kEnd - 1, y);
 
                 // apply Householder transforms to solve Q.y = b
-                for (int minor = 0; minor < AccurateMath.min(m, n); minor++) {
+                for (int minor = 0; minor < JdkMath.min(m, n); minor++) {
                     final double[] qrtMinor = qrt[minor];
                     final double factor     = 1.0 / (rDiag[minor] * qrtMinor[minor]);
 
@@ -490,7 +490,7 @@
             final int len = diag.length;
             for (int i = 0; i < len; i++) {
                 final double d = diag[i];
-                if (AccurateMath.abs(d) <= min) {
+                if (JdkMath.abs(d) <= min) {
                     if (raise) {
                         final SingularMatrixException e = new SingularMatrixException();
                         e.getContext().addMessage(LocalizedFormats.NUMBER_TOO_SMALL, d, min);
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/RRQRDecomposition.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/RRQRDecomposition.java
index 40df29c..9988f8f 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/RRQRDecomposition.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/RRQRDecomposition.java
@@ -17,7 +17,7 @@
 
 package org.apache.commons.math4.legacy.linear;
 
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 
 /**
@@ -169,7 +169,7 @@
         int rank        = 1;
         double lastNorm = r.getFrobeniusNorm();
         double rNorm    = lastNorm;
-        while (rank < AccurateMath.min(rows, columns)) {
+        while (rank < JdkMath.min(rows, columns)) {
             double thisNorm = r.getSubMatrix(rank, rows - 1, rank, columns - 1).getFrobeniusNorm();
             if (thisNorm == 0 || (thisNorm / lastNorm) * rNorm < dropThreshold) {
                 break;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/RealVector.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/RealVector.java
index fbeea9b..e581b2a 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/RealVector.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/RealVector.java
@@ -32,7 +32,7 @@
 import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Class defining a real-valued vector with basic algebraic operations.
@@ -380,7 +380,7 @@
             final double diff = e.getValue() - v.getEntry(e.getIndex());
             d += diff * diff;
         }
-        return AccurateMath.sqrt(d);
+        return JdkMath.sqrt(d);
     }
 
     /**
@@ -401,7 +401,7 @@
             final double value = e.getValue();
             sum += value * value;
         }
-        return AccurateMath.sqrt(sum);
+        return JdkMath.sqrt(sum);
     }
 
     /**
@@ -419,7 +419,7 @@
         Iterator<Entry> it = iterator();
         while (it.hasNext()) {
             final Entry e = it.next();
-            norm += AccurateMath.abs(e.getValue());
+            norm += JdkMath.abs(e.getValue());
         }
         return norm;
     }
@@ -439,7 +439,7 @@
         Iterator<Entry> it = iterator();
         while (it.hasNext()) {
             final Entry e = it.next();
-            norm = AccurateMath.max(norm, AccurateMath.abs(e.getValue()));
+            norm = JdkMath.max(norm, JdkMath.abs(e.getValue()));
         }
         return norm;
     }
@@ -462,7 +462,7 @@
         Iterator<Entry> it = iterator();
         while (it.hasNext()) {
             final Entry e = it.next();
-            d += AccurateMath.abs(e.getValue() - v.getEntry(e.getIndex()));
+            d += JdkMath.abs(e.getValue() - v.getEntry(e.getIndex()));
         }
         return d;
     }
@@ -488,7 +488,7 @@
         Iterator<Entry> it = iterator();
         while (it.hasNext()) {
             final Entry e = it.next();
-            d = AccurateMath.max(AccurateMath.abs(e.getValue() - v.getEntry(e.getIndex())), d);
+            d = JdkMath.max(JdkMath.abs(e.getValue() - v.getEntry(e.getIndex())), d);
         }
         return d;
     }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/RectangularCholeskyDecomposition.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/RectangularCholeskyDecomposition.java
index 68882a5..9e57cd6 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/RectangularCholeskyDecomposition.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/RectangularCholeskyDecomposition.java
@@ -17,7 +17,7 @@
 
 package org.apache.commons.math4.legacy.linear;
 
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Calculates the rectangular Cholesky decomposition of a matrix.
@@ -138,7 +138,7 @@
             } else {
 
                 // transform the matrix
-                final double sqrt = AccurateMath.sqrt(c[ir][ir]);
+                final double sqrt = JdkMath.sqrt(c[ir][ir]);
                 b[r][r] = sqrt;
                 final double inverse  = 1 / sqrt;
                 final double inverse2 = 1 / c[ir][ir];
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/SchurTransformer.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/SchurTransformer.java
index 2aa8273..f5182ad 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/SchurTransformer.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/SchurTransformer.java
@@ -19,7 +19,7 @@
 
 import org.apache.commons.math4.legacy.exception.MaxCountExceededException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.numbers.core.Precision;
 
 /**
@@ -159,17 +159,17 @@
                 matrixT[iu - 1][iu - 1] += shift.exShift;
 
                 if (q >= 0) {
-                    double z = AccurateMath.sqrt(AccurateMath.abs(q));
+                    double z = JdkMath.sqrt(JdkMath.abs(q));
                     if (p >= 0) {
                         z = p + z;
                     } else {
                         z = p - z;
                     }
                     final double x = matrixT[iu][iu - 1];
-                    final double s = AccurateMath.abs(x) + AccurateMath.abs(z);
+                    final double s = JdkMath.abs(x) + JdkMath.abs(z);
                     p = x / s;
                     q = z / s;
-                    final double r = AccurateMath.sqrt(p * p + q * q);
+                    final double r = JdkMath.sqrt(p * p + q * q);
                     p /= r;
                     q /= r;
 
@@ -224,8 +224,8 @@
         double norm = 0.0;
         for (int i = 0; i < matrixT.length; i++) {
             // as matrix T is (quasi-)triangular, also take the sub-diagonal element into account
-            for (int j = AccurateMath.max(i - 1, 0); j < matrixT.length; j++) {
-                norm += AccurateMath.abs(matrixT[i][j]);
+            for (int j = JdkMath.max(i - 1, 0); j < matrixT.length; j++) {
+                norm += JdkMath.abs(matrixT[i][j]);
             }
         }
         return norm;
@@ -241,11 +241,11 @@
     private int findSmallSubDiagonalElement(final int startIdx, final double norm) {
         int l = startIdx;
         while (l > 0) {
-            double s = AccurateMath.abs(matrixT[l - 1][l - 1]) + AccurateMath.abs(matrixT[l][l]);
+            double s = JdkMath.abs(matrixT[l - 1][l - 1]) + JdkMath.abs(matrixT[l][l]);
             if (s == 0.0) {
                 s = norm;
             }
-            if (AccurateMath.abs(matrixT[l][l - 1]) < epsilon * s) {
+            if (JdkMath.abs(matrixT[l][l - 1]) < epsilon * s) {
                 break;
             }
             l--;
@@ -276,7 +276,7 @@
             for (int i = 0; i <= idx; i++) {
                 matrixT[i][i] -= shift.x;
             }
-            final double s = AccurateMath.abs(matrixT[idx][idx - 1]) + AccurateMath.abs(matrixT[idx - 1][idx - 2]);
+            final double s = JdkMath.abs(matrixT[idx][idx - 1]) + JdkMath.abs(matrixT[idx - 1][idx - 2]);
             shift.x = 0.75 * s;
             shift.y = 0.75 * s;
             shift.w = -0.4375 * s * s;
@@ -287,7 +287,7 @@
             double s = (shift.y - shift.x) / 2.0;
             s = s * s + shift.w;
             if (s > 0.0) {
-                s = AccurateMath.sqrt(s);
+                s = JdkMath.sqrt(s);
                 if (shift.y < shift.x) {
                     s = -s;
                 }
@@ -325,10 +325,10 @@
                 break;
             }
 
-            final double lhs = AccurateMath.abs(matrixT[im][im - 1]) * (AccurateMath.abs(hVec[1]) + AccurateMath.abs(hVec[2]));
-            final double rhs = AccurateMath.abs(hVec[0]) * (AccurateMath.abs(matrixT[im - 1][im - 1]) +
-                                                        AccurateMath.abs(z) +
-                                                        AccurateMath.abs(matrixT[im + 1][im + 1]));
+            final double lhs = JdkMath.abs(matrixT[im][im - 1]) * (JdkMath.abs(hVec[1]) + JdkMath.abs(hVec[2]));
+            final double rhs = JdkMath.abs(hVec[0]) * (JdkMath.abs(matrixT[im - 1][im - 1]) +
+                                                        JdkMath.abs(z) +
+                                                        JdkMath.abs(matrixT[im + 1][im + 1]));
 
             if (lhs < epsilon * rhs) {
                 break;
@@ -362,7 +362,7 @@
                 p = matrixT[k][k - 1];
                 q = matrixT[k + 1][k - 1];
                 r = notlast ? matrixT[k + 2][k - 1] : 0.0;
-                shift.x = AccurateMath.abs(p) + AccurateMath.abs(q) + AccurateMath.abs(r);
+                shift.x = JdkMath.abs(p) + JdkMath.abs(q) + JdkMath.abs(r);
                 if (Precision.equals(shift.x, 0.0, epsilon)) {
                     continue;
                 }
@@ -370,7 +370,7 @@
                 q /= shift.x;
                 r /= shift.x;
             }
-            double s = AccurateMath.sqrt(p * p + q * q + r * r);
+            double s = JdkMath.sqrt(p * p + q * q + r * r);
             if (p < 0.0) {
                 s = -s;
             }
@@ -399,7 +399,7 @@
                 }
 
                 // Column modification
-                for (int i = 0; i <= AccurateMath.min(iu, k + 3); i++) {
+                for (int i = 0; i <= JdkMath.min(iu, k + 3); i++) {
                     p = shift.x * matrixT[i][k] + shift.y * matrixT[i][k + 1];
                     if (notlast) {
                         p += z * matrixT[i][k + 2];
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/SingularValueDecomposition.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/SingularValueDecomposition.java
index fe8ea64..610ce83 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/SingularValueDecomposition.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/SingularValueDecomposition.java
@@ -18,7 +18,7 @@
 
 import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.numbers.core.Precision;
 
 /**
@@ -107,16 +107,16 @@
         final double[] work = new double[m];
         // Reduce A to bidiagonal form, storing the diagonal elements
         // in s and the super-diagonal elements in e.
-        final int nct = AccurateMath.min(m - 1, n);
-        final int nrt = AccurateMath.max(0, n - 2);
-        for (int k = 0; k < AccurateMath.max(nct, nrt); k++) {
+        final int nct = JdkMath.min(m - 1, n);
+        final int nrt = JdkMath.max(0, n - 2);
+        for (int k = 0; k < JdkMath.max(nct, nrt); k++) {
             if (k < nct) {
                 // Compute the transformation for the k-th column and
                 // place the k-th diagonal in s[k].
                 // Compute 2-norm of k-th column without under/overflow.
                 singularValues[k] = 0;
                 for (int i = k; i < m; i++) {
-                    singularValues[k] = AccurateMath.hypot(singularValues[k], A[i][k]);
+                    singularValues[k] = JdkMath.hypot(singularValues[k], A[i][k]);
                 }
                 if (singularValues[k] != 0) {
                     if (A[k][k] < 0) {
@@ -159,7 +159,7 @@
                 // Compute 2-norm without under/overflow.
                 e[k] = 0;
                 for (int i = k + 1; i < n; i++) {
-                    e[k] = AccurateMath.hypot(e[k], e[i]);
+                    e[k] = JdkMath.hypot(e[k], e[i]);
                 }
                 if (e[k] != 0) {
                     if (e[k + 1] < 0) {
@@ -281,16 +281,16 @@
             // kase = 4     if e(p-1) is negligible (convergence).
             for (k = p - 2; k >= 0; k--) {
                 final double threshold
-                    = TINY + EPS * (AccurateMath.abs(singularValues[k]) +
-                                    AccurateMath.abs(singularValues[k + 1]));
+                    = TINY + EPS * (JdkMath.abs(singularValues[k]) +
+                                    JdkMath.abs(singularValues[k + 1]));
 
                 // the following condition is written this way in order
                 // to break out of the loop when NaN occurs, writing it
-                // as "if (AccurateMath.abs(e[k]) <= threshold)" would loop
+                // as "if (JdkMath.abs(e[k]) <= threshold)" would loop
                 // indefinitely in case of NaNs because comparison on NaNs
                 // always return false, regardless of what is checked
                 // see issue MATH-947
-                if (!(AccurateMath.abs(e[k]) > threshold)) {
+                if (!(JdkMath.abs(e[k]) > threshold)) {
                     e[k] = 0;
                     break;
                 }
@@ -305,9 +305,9 @@
                     if (ks == k) {
                         break;
                     }
-                    final double t = (ks != p ? AccurateMath.abs(e[ks]) : 0) +
-                        (ks != k + 1 ? AccurateMath.abs(e[ks - 1]) : 0);
-                    if (AccurateMath.abs(singularValues[ks]) <= TINY + EPS * t) {
+                    final double t = (ks != p ? JdkMath.abs(e[ks]) : 0) +
+                        (ks != k + 1 ? JdkMath.abs(e[ks - 1]) : 0);
+                    if (JdkMath.abs(singularValues[ks]) <= TINY + EPS * t) {
                         singularValues[ks] = 0;
                         break;
                     }
@@ -330,7 +330,7 @@
                     f = e[p - 2];
                     e[p - 2] = 0;
                     for (int j = p - 2; j >= k; j--) {
-                        double t = AccurateMath.hypot(singularValues[j], f);
+                        double t = JdkMath.hypot(singularValues[j], f);
                         final double cs = singularValues[j] / t;
                         final double sn = f / t;
                         singularValues[j] = t;
@@ -351,7 +351,7 @@
                     f = e[k - 1];
                     e[k - 1] = 0;
                     for (int j = k; j < p; j++) {
-                        double t = AccurateMath.hypot(singularValues[j], f);
+                        double t = JdkMath.hypot(singularValues[j], f);
                         final double cs = singularValues[j] / t;
                         final double sn = f / t;
                         singularValues[j] = t;
@@ -368,12 +368,12 @@
                 // Perform one qr step.
                 case 3:
                     // Calculate the shift.
-                    final double maxPm1Pm2 = AccurateMath.max(AccurateMath.abs(singularValues[p - 1]),
-                                                          AccurateMath.abs(singularValues[p - 2]));
-                    final double scale = AccurateMath.max(AccurateMath.max(AccurateMath.max(maxPm1Pm2,
-                                                                                AccurateMath.abs(e[p - 2])),
-                                                                   AccurateMath.abs(singularValues[k])),
-                                                      AccurateMath.abs(e[k]));
+                    final double maxPm1Pm2 = JdkMath.max(JdkMath.abs(singularValues[p - 1]),
+                                                          JdkMath.abs(singularValues[p - 2]));
+                    final double scale = JdkMath.max(JdkMath.max(JdkMath.max(maxPm1Pm2,
+                                                                                JdkMath.abs(e[p - 2])),
+                                                                   JdkMath.abs(singularValues[k])),
+                                                      JdkMath.abs(e[k]));
                     final double sp = singularValues[p - 1] / scale;
                     final double spm1 = singularValues[p - 2] / scale;
                     final double epm1 = e[p - 2] / scale;
@@ -384,7 +384,7 @@
                     double shift = 0;
                     if (b != 0 ||
                         c != 0) {
-                        shift = AccurateMath.sqrt(b * b + c);
+                        shift = JdkMath.sqrt(b * b + c);
                         if (b < 0) {
                             shift = -shift;
                         }
@@ -394,7 +394,7 @@
                     double g = sk * ek;
                     // Chase zeros.
                     for (int j = k; j < p - 1; j++) {
-                        double t = AccurateMath.hypot(f, g);
+                        double t = JdkMath.hypot(f, g);
                         double cs = f / t;
                         double sn = g / t;
                         if (j != k) {
@@ -410,7 +410,7 @@
                             V[i][j + 1] = -sn * V[i][j] + cs * V[i][j + 1];
                             V[i][j] = t;
                         }
-                        t = AccurateMath.hypot(f, g);
+                        t = JdkMath.hypot(f, g);
                         cs = f / t;
                         sn = g / t;
                         singularValues[j] = t;
@@ -468,8 +468,8 @@
         }
 
         // Set the small value tolerance used to calculate rank and pseudo-inverse
-        tol = AccurateMath.max(m * singularValues[0] * EPS,
-                           AccurateMath.sqrt(Precision.SAFE_MIN));
+        tol = JdkMath.max(m * singularValues[0] * EPS,
+                           JdkMath.sqrt(Precision.SAFE_MIN));
 
         if (!transposed) {
             cachedU = MatrixUtils.createRealMatrix(U);
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/SymmLQ.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/SymmLQ.java
index 77880c1..3392521 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/SymmLQ.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/SymmLQ.java
@@ -20,7 +20,7 @@
 import org.apache.commons.math4.legacy.exception.MaxCountExceededException;
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
 import org.apache.commons.math4.legacy.exception.util.ExceptionContext;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * <p>
@@ -360,8 +360,8 @@
         private boolean bIsNull;
 
         static {
-            MACH_PREC = AccurateMath.ulp(1.);
-            CBRT_MACH_PREC = AccurateMath.cbrt(MACH_PREC);
+            MACH_PREC = JdkMath.ulp(1.);
+            CBRT_MACH_PREC = JdkMath.cbrt(MACH_PREC);
         }
 
         /**
@@ -416,7 +416,7 @@
             final double s = y.dotProduct(y);
             final double t = x.dotProduct(z);
             final double epsa = (s + MACH_PREC) * CBRT_MACH_PREC;
-            if (AccurateMath.abs(s - t) > epsa) {
+            if (JdkMath.abs(s - t) > epsa) {
                 final NonSelfAdjointOperatorException e;
                 e = new NonSelfAdjointOperatorException();
                 final ExceptionContext context = e.getContext();
@@ -511,11 +511,11 @@
                     }
                 }
             } else {
-                final double anorm = AccurateMath.sqrt(tnorm);
+                final double anorm = JdkMath.sqrt(tnorm);
                 final double diag = gbar == 0. ? anorm * MACH_PREC : gbar;
                 final double zbar = gammaZeta / diag;
                 final double step = (bstep + snprod * zbar) / beta1;
-                // ynorm = AccurateMath.sqrt(ynorm2 + zbar * zbar);
+                // ynorm = JdkMath.sqrt(ynorm2 + zbar * zbar);
                 if (!goodb) {
                     for (int i = 0; i < n; i++) {
                         final double xi = this.xL.getEntry(i);
@@ -560,7 +560,7 @@
                 return;
             }
             this.bIsNull = false;
-            this.beta1 = AccurateMath.sqrt(this.beta1);
+            this.beta1 = JdkMath.sqrt(this.beta1);
             /* At this point
              *   r1 = b,
              *   y = M * b,
@@ -596,7 +596,7 @@
             if (this.beta < 0.) {
                 throwNPDLOException(this.m, this.y);
             }
-            this.beta = AccurateMath.sqrt(this.beta);
+            this.beta = JdkMath.sqrt(this.beta);
             /*
              * At this point
              *   oldb = beta[1]
@@ -613,7 +613,7 @@
             this.snprod = 1.;
             this.tnorm = alpha * alpha + this.beta * this.beta;
             this.ynorm2 = 0.;
-            this.gmax = AccurateMath.abs(alpha) + MACH_PREC;
+            this.gmax = JdkMath.abs(alpha) + MACH_PREC;
             this.gmin = this.gmax;
 
             if (this.goodb) {
@@ -670,7 +670,7 @@
             if (beta < 0.) {
                 throwNPDLOException(m, y);
             }
-            beta = AccurateMath.sqrt(beta);
+            beta = JdkMath.sqrt(beta);
             /*
              * At this point
              *   r1 = beta[k] * M^(-1) * P' * v[k],
@@ -687,7 +687,7 @@
              *   c     = c[k-1],
              *   s     = s[k-1].
              */
-            final double gamma = AccurateMath.sqrt(gbar * gbar + oldb * oldb);
+            final double gamma = JdkMath.sqrt(gbar * gbar + oldb * oldb);
             final double c = gbar / gamma;
             final double s = oldb / gamma;
             /*
@@ -730,8 +730,8 @@
              */
             bstep += snprod * c * zeta;
             snprod *= s;
-            gmax = AccurateMath.max(gmax, gamma);
-            gmin = AccurateMath.min(gmin, gamma);
+            gmax = JdkMath.max(gmax, gamma);
+            gmin = JdkMath.min(gmin, gamma);
             ynorm2 += zeta * zeta;
             gammaZeta = minusEpsZeta - deltak * zeta;
             minusEpsZeta = -eps * zeta;
@@ -755,16 +755,16 @@
          * Updates {@link #lqnorm} and {@link #cgnorm}.
          */
         private void updateNorms() {
-            final double anorm = AccurateMath.sqrt(tnorm);
-            final double ynorm = AccurateMath.sqrt(ynorm2);
+            final double anorm = JdkMath.sqrt(tnorm);
+            final double ynorm = JdkMath.sqrt(ynorm2);
             final double epsa = anorm * MACH_PREC;
             final double epsx = anorm * ynorm * MACH_PREC;
             final double epsr = anorm * ynorm * delta;
             final double diag = gbar == 0. ? epsa : gbar;
-            lqnorm = AccurateMath.sqrt(gammaZeta * gammaZeta +
+            lqnorm = JdkMath.sqrt(gammaZeta * gammaZeta +
                                    minusEpsZeta * minusEpsZeta);
             final double qrnorm = snprod * beta1;
-            cgnorm = qrnorm * beta / AccurateMath.abs(diag);
+            cgnorm = qrnorm * beta / JdkMath.abs(diag);
 
             /*
              * Estimate cond(A). In this version we look at the diagonals of L
@@ -776,7 +776,7 @@
             if (lqnorm <= cgnorm) {
                 acond = gmax / gmin;
             } else {
-                acond = gmax / AccurateMath.min(gmin, AccurateMath.abs(diag));
+                acond = gmax / JdkMath.min(gmin, JdkMath.abs(diag));
             }
             if (acond * MACH_PREC >= 0.1) {
                 throw new IllConditionedOperatorException(acond);
@@ -788,7 +788,7 @@
                  */
                 throw new SingularOperatorException();
             }
-            rnorm = AccurateMath.min(cgnorm, lqnorm);
+            rnorm = JdkMath.min(cgnorm, lqnorm);
             hasConverged = (cgnorm <= epsx) || (cgnorm <= epsr);
         }
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/TriDiagonalTransformer.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/TriDiagonalTransformer.java
index f57ba2b..1320eb6 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/TriDiagonalTransformer.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/TriDiagonalTransformer.java
@@ -19,7 +19,7 @@
 
 import java.util.Arrays;
 
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 
 /**
@@ -201,7 +201,7 @@
                 final double c = hK[j];
                 xNormSqr += c * c;
             }
-            final double a = (hK[k + 1] > 0) ? -AccurateMath.sqrt(xNormSqr) : AccurateMath.sqrt(xNormSqr);
+            final double a = (hK[k + 1] > 0) ? -JdkMath.sqrt(xNormSqr) : JdkMath.sqrt(xNormSqr);
             secondary[k] = a;
             if (a != 0.0) {
                 // apply Householder transform from left and right simultaneously
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ml/clustering/FuzzyKMeansClusterer.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ml/clustering/FuzzyKMeansClusterer.java
index 69c9712..c5dcba5 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ml/clustering/FuzzyKMeansClusterer.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ml/clustering/FuzzyKMeansClusterer.java
@@ -30,7 +30,7 @@
 import org.apache.commons.math4.legacy.ml.distance.EuclideanDistance;
 import org.apache.commons.rng.simple.RandomSource;
 import org.apache.commons.rng.UniformRandomProvider;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 
 /**
@@ -244,7 +244,7 @@
             int j = 0;
             for (final CentroidCluster<T> cluster : clusters) {
                 final double dist = distance(point, cluster.getCenter());
-                objFunction += (dist * dist) * AccurateMath.pow(membershipMatrix[i][j], fuzziness);
+                objFunction += (dist * dist) * JdkMath.pow(membershipMatrix[i][j], fuzziness);
                 j++;
             }
             i++;
@@ -318,7 +318,7 @@
             double[] arr = new double[center.getPoint().length];
             double sum = 0.0;
             for (final T point : points) {
-                final double u = AccurateMath.pow(membershipMatrix[i][j], fuzziness);
+                final double u = JdkMath.pow(membershipMatrix[i][j], fuzziness);
                 final double[] pointArr = point.getPoint();
                 for (int idx = 0; idx < arr.length; idx++) {
                     arr[idx] += u * pointArr[idx];
@@ -345,16 +345,16 @@
             int newCluster = -1;
             for (int j = 0; j < clusters.size(); j++) {
                 double sum = 0.0;
-                final double distA = AccurateMath.abs(distance(point, clusters.get(j).getCenter()));
+                final double distA = JdkMath.abs(distance(point, clusters.get(j).getCenter()));
 
                 if (distA != 0.0) {
                     for (final CentroidCluster<T> c : clusters) {
-                        final double distB = AccurateMath.abs(distance(point, c.getCenter()));
+                        final double distB = JdkMath.abs(distance(point, c.getCenter()));
                         if (distB == 0.0) {
                             sum = Double.POSITIVE_INFINITY;
                             break;
                         }
-                        sum += AccurateMath.pow(distA / distB, 2.0 / (fuzziness - 1.0));
+                        sum += JdkMath.pow(distA / distB, 2.0 / (fuzziness - 1.0));
                     }
                 }
 
@@ -400,8 +400,8 @@
         double maxMembership = 0.0;
         for (int i = 0; i < points.size(); i++) {
             for (int j = 0; j < clusters.size(); j++) {
-                double v = AccurateMath.abs(membershipMatrix[i][j] - matrix[i][j]);
-                maxMembership = AccurateMath.max(v, maxMembership);
+                double v = JdkMath.abs(membershipMatrix[i][j] - matrix[i][j]);
+                maxMembership = JdkMath.max(v, maxMembership);
             }
         }
         return maxMembership;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ml/distance/CanberraDistance.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ml/distance/CanberraDistance.java
index 628ee6d..8da4390 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ml/distance/CanberraDistance.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ml/distance/CanberraDistance.java
@@ -17,7 +17,7 @@
 package org.apache.commons.math4.legacy.ml.distance;
 
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 
 /**
@@ -37,8 +37,8 @@
         MathArrays.checkEqualLength(a, b);
         double sum = 0;
         for (int i = 0; i < a.length; i++) {
-            final double num = AccurateMath.abs(a[i] - b[i]);
-            final double denom = AccurateMath.abs(a[i]) + AccurateMath.abs(b[i]);
+            final double num = JdkMath.abs(a[i] - b[i]);
+            final double denom = JdkMath.abs(a[i]) + JdkMath.abs(b[i]);
             sum += num == 0.0 && denom == 0.0 ? 0.0 : num / denom;
         }
         return sum;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ml/distance/EarthMoversDistance.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ml/distance/EarthMoversDistance.java
index fd72d46..c62b570 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ml/distance/EarthMoversDistance.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ml/distance/EarthMoversDistance.java
@@ -17,7 +17,7 @@
 package org.apache.commons.math4.legacy.ml.distance;
 
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 
 /**
@@ -41,7 +41,7 @@
         double totalDistance = 0;
         for (int i = 0; i < a.length; i++) {
             final double currentDistance = (a[i] + lastDistance) - b[i];
-            totalDistance += AccurateMath.abs(currentDistance);
+            totalDistance += JdkMath.abs(currentDistance);
             lastDistance = currentDistance;
         }
         return totalDistance;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/AbstractFieldIntegrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/AbstractFieldIntegrator.java
index 8b7ba29..5658f6f 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/AbstractFieldIntegrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/AbstractFieldIntegrator.java
@@ -39,7 +39,7 @@
 import org.apache.commons.math4.legacy.ode.events.FieldEventState;
 import org.apache.commons.math4.legacy.ode.sampling.AbstractFieldStepInterpolator;
 import org.apache.commons.math4.legacy.ode.sampling.FieldStepHandler;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.IntegerSequence;
 
 /**
@@ -385,7 +385,7 @@
                 state.stepAccepted(currentState);
                 isLastStep = isLastStep || state.stop();
             }
-            isLastStep = isLastStep || currentState.getTime().subtract(tEnd).abs().getReal() <= AccurateMath.ulp(tEnd.getReal());
+            isLastStep = isLastStep || currentState.getTime().subtract(tEnd).abs().getReal() <= JdkMath.ulp(tEnd.getReal());
 
             // handle the remaining part of the step, after all events if any
             for (FieldStepHandler<T> handler : stepHandlers) {
@@ -406,8 +406,8 @@
     protected void sanityChecks(final FieldODEState<T> eqn, final T t)
         throws NumberIsTooSmallException, DimensionMismatchException {
 
-        final double threshold = 1000 * AccurateMath.ulp(AccurateMath.max(AccurateMath.abs(eqn.getTime().getReal()),
-                                                                  AccurateMath.abs(t.getReal())));
+        final double threshold = 1000 * JdkMath.ulp(JdkMath.max(JdkMath.abs(eqn.getTime().getReal()),
+                                                                  JdkMath.abs(t.getReal())));
         final double dt = eqn.getTime().subtract(t).abs().getReal();
         if (dt <= threshold) {
             throw new NumberIsTooSmallException(LocalizedFormats.TOO_SMALL_INTEGRATION_INTERVAL,
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/AbstractIntegrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/AbstractIntegrator.java
index 25f1c16..9a3945e 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/AbstractIntegrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/AbstractIntegrator.java
@@ -37,7 +37,7 @@
 import org.apache.commons.math4.legacy.ode.events.EventState;
 import org.apache.commons.math4.legacy.ode.sampling.AbstractStepInterpolator;
 import org.apache.commons.math4.legacy.ode.sampling.StepHandler;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.IntegerSequence;
 import org.apache.commons.numbers.core.Precision;
 
@@ -458,9 +458,9 @@
     protected void sanityChecks(final ExpandableStatefulODE equations, final double t)
         throws NumberIsTooSmallException, DimensionMismatchException {
 
-        final double threshold = 1000 * AccurateMath.ulp(AccurateMath.max(AccurateMath.abs(equations.getTime()),
-                                                                  AccurateMath.abs(t)));
-        final double dt = AccurateMath.abs(equations.getTime() - t);
+        final double threshold = 1000 * JdkMath.ulp(JdkMath.max(JdkMath.abs(equations.getTime()),
+                                                                  JdkMath.abs(t)));
+        final double dt = JdkMath.abs(equations.getTime() - t);
         if (dt <= threshold) {
             throw new NumberIsTooSmallException(LocalizedFormats.TOO_SMALL_INTEGRATION_INTERVAL,
                                                 dt, threshold, false);
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/ContinuousOutputFieldModel.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/ContinuousOutputFieldModel.java
index b2656a1..85e8ff6 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/ContinuousOutputFieldModel.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/ContinuousOutputFieldModel.java
@@ -27,7 +27,7 @@
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
 import org.apache.commons.math4.legacy.ode.sampling.FieldStepHandler;
 import org.apache.commons.math4.legacy.ode.sampling.FieldStepInterpolator;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * This class stores all information provided by an ODE integrator
@@ -292,12 +292,12 @@
                                      subtract(dt1.multiply(dt3).multiply(d13).multiply(iMed)).
                                      add(     dt1.multiply(dt2).multiply(d12).multiply(iMin)).
                                      divide(d12.multiply(d23).multiply(d13));
-                index = (int) AccurateMath.rint(iLagrange.getReal());
+                index = (int) JdkMath.rint(iLagrange.getReal());
             }
 
             // force the next size reduction to be at least one tenth
-            final int low  = AccurateMath.max(iMin + 1, (9 * iMin + iMax) / 10);
-            final int high = AccurateMath.min(iMax - 1, (iMin + 9 * iMax) / 10);
+            final int low  = JdkMath.max(iMin + 1, (9 * iMin + iMax) / 10);
+            final int high = JdkMath.min(iMax - 1, (iMin + 9 * iMax) / 10);
             if (index < low) {
                 index = low;
             } else if (index > high) {
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/ContinuousOutputModel.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/ContinuousOutputModel.java
index 4e29d22..c062e3f 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/ContinuousOutputModel.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/ContinuousOutputModel.java
@@ -27,7 +27,7 @@
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
 import org.apache.commons.math4.legacy.ode.sampling.StepHandler;
 import org.apache.commons.math4.legacy.ode.sampling.StepInterpolator;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * This class stores all information provided by an ODE integrator
@@ -152,9 +152,9 @@
       final double previous = lastInterpolator.getPreviousTime();
       final double step = current - previous;
       final double gap = model.getInitialTime() - current;
-      if (AccurateMath.abs(gap) > 1.0e-3 * AccurateMath.abs(step)) {
+      if (JdkMath.abs(gap) > 1.0e-3 * JdkMath.abs(step)) {
         throw new MathIllegalArgumentException(LocalizedFormats.HOLE_BETWEEN_MODELS_TIME_RANGES,
-                                               AccurateMath.abs(gap));
+                                               JdkMath.abs(gap));
       }
 
     }
@@ -296,7 +296,7 @@
         final StepInterpolator sMed = steps.get(iMed);
         final double tMed = 0.5 * (sMed.getPreviousTime() + sMed.getCurrentTime());
 
-        if ((AccurateMath.abs(tMed - tMin) < 1e-6) || (AccurateMath.abs(tMax - tMed) < 1e-6)) {
+        if ((JdkMath.abs(tMed - tMin) < 1e-6) || (JdkMath.abs(tMax - tMed) < 1e-6)) {
           // too close to the bounds, we estimate using a simple dichotomy
           index = iMed;
         } else {
@@ -313,12 +313,12 @@
                                     (dt1 * dt3 * d13) * iMed +
                                     (dt1 * dt2 * d12) * iMin) /
                                    (d12 * d23 * d13);
-          index = (int) AccurateMath.rint(iLagrange);
+          index = (int) JdkMath.rint(iLagrange);
         }
 
         // force the next size reduction to be at least one tenth
-        final int low  = AccurateMath.max(iMin + 1, (9 * iMin + iMax) / 10);
-        final int high = AccurateMath.min(iMax - 1, (iMin + 9 * iMax) / 10);
+        final int low  = JdkMath.max(iMin + 1, (9 * iMin + iMax) / 10);
+        final int high = JdkMath.min(iMax - 1, (iMin + 9 * iMax) / 10);
         if (index < low) {
           index = low;
         } else if (index > high) {
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/JacobianMatrices.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/JacobianMatrices.java
index e326611..481237c 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/JacobianMatrices.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/JacobianMatrices.java
@@ -198,7 +198,7 @@
      * </p>
      * <p>
      * Given a non zero parameter value pval for the parameter, a reasonable value
-     * for such a step is {@code pval * AccurateMath.sqrt(Precision.EPSILON)}.
+     * for such a step is {@code pval * JdkMath.sqrt(Precision.EPSILON)}.
      * </p>
      * <p>
      * A zero value for such a step doesn't enable to compute the parameter Jacobian matrix.
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/MultistepFieldIntegrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/MultistepFieldIntegrator.java
index a25518d..2e6c114 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/MultistepFieldIntegrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/MultistepFieldIntegrator.java
@@ -30,7 +30,7 @@
 import org.apache.commons.math4.legacy.ode.nonstiff.DormandPrince853FieldIntegrator;
 import org.apache.commons.math4.legacy.ode.sampling.FieldStepHandler;
 import org.apache.commons.math4.legacy.ode.sampling.FieldStepInterpolator;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 
 /**
@@ -139,7 +139,7 @@
         // set the default values of the algorithm control parameters
         setSafety(0.9);
         setMinReduction(0.2);
-        setMaxGrowth(AccurateMath.pow(2.0, -exp));
+        setMaxGrowth(JdkMath.pow(2.0, -exp));
 
     }
 
@@ -179,7 +179,7 @@
         // set the default values of the algorithm control parameters
         setSafety(0.9);
         setMinReduction(0.2);
-        setMaxGrowth(AccurateMath.pow(2.0, -exp));
+        setMaxGrowth(JdkMath.pow(2.0, -exp));
 
     }
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/MultistepIntegrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/MultistepIntegrator.java
index 222f663..42cf07e 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/MultistepIntegrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/MultistepIntegrator.java
@@ -28,7 +28,7 @@
 import org.apache.commons.math4.legacy.ode.nonstiff.DormandPrince853Integrator;
 import org.apache.commons.math4.legacy.ode.sampling.StepHandler;
 import org.apache.commons.math4.legacy.ode.sampling.StepInterpolator;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * This class is the base class for multistep integrators for Ordinary
@@ -133,7 +133,7 @@
         // set the default values of the algorithm control parameters
         setSafety(0.9);
         setMinReduction(0.2);
-        setMaxGrowth(AccurateMath.pow(2.0, -exp));
+        setMaxGrowth(JdkMath.pow(2.0, -exp));
 
     }
 
@@ -172,7 +172,7 @@
         // set the default values of the algorithm control parameters
         setSafety(0.9);
         setMinReduction(0.2);
-        setMaxGrowth(AccurateMath.pow(2.0, -exp));
+        setMaxGrowth(JdkMath.pow(2.0, -exp));
 
     }
 
@@ -331,7 +331,7 @@
      * @return grow/shrink factor for next step
      */
     protected double computeStepGrowShrinkFactor(final double error) {
-        return AccurateMath.min(maxGrowth, AccurateMath.max(minReduction, safety * AccurateMath.pow(error, exp)));
+        return JdkMath.min(maxGrowth, JdkMath.max(minReduction, safety * JdkMath.pow(error, exp)));
     }
 
     /** Transformer used to convert the first step to Nordsieck representation.
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/events/EventState.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/events/EventState.java
index eeec951..aa4f1a6 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/events/EventState.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/events/EventState.java
@@ -28,7 +28,7 @@
 import org.apache.commons.math4.legacy.ode.EquationsMapper;
 import org.apache.commons.math4.legacy.ode.ExpandableStatefulODE;
 import org.apache.commons.math4.legacy.ode.sampling.StepInterpolator;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /** This class handles the state for one {@link EventHandler
  * event handler} during integration steps.
@@ -106,7 +106,7 @@
                       final UnivariateSolver solver) {
         this.handler           = handler;
         this.maxCheckInterval  = maxCheckInterval;
-        this.convergence       = AccurateMath.abs(convergence);
+        this.convergence       = JdkMath.abs(convergence);
         this.maxIterationCount = maxIterationCount;
         this.solver            = solver;
 
@@ -183,8 +183,8 @@
 
             // extremely rare case: there is a zero EXACTLY at interval start
             // we will use the sign slightly after step beginning to force ignoring this zero
-            final double epsilon = AccurateMath.max(solver.getAbsoluteAccuracy(),
-                                                AccurateMath.abs(solver.getRelativeAccuracy() * t0));
+            final double epsilon = JdkMath.max(solver.getAbsoluteAccuracy(),
+                                                JdkMath.abs(solver.getRelativeAccuracy() * t0));
             final double tStart = t0 + 0.5 * epsilon;
             interpolator.setInterpolatedTime(tStart);
             g0 = handler.g(tStart, getCompleteState(interpolator));
@@ -228,11 +228,11 @@
             forward = interpolator.isForward();
             final double t1 = interpolator.getCurrentTime();
             final double dt = t1 - t0;
-            if (AccurateMath.abs(dt) < convergence) {
+            if (JdkMath.abs(dt) < convergence) {
                 // we cannot do anything on such a small step, don't trigger any events
                 return false;
             }
-            final int    n = AccurateMath.max(1, (int) AccurateMath.ceil(AccurateMath.abs(dt) / maxCheckInterval));
+            final int    n = JdkMath.max(1, (int) JdkMath.ceil(JdkMath.abs(dt) / maxCheckInterval));
             final double h = dt / n;
 
             final UnivariateFunction f = new UnivariateFunction() {
@@ -288,8 +288,8 @@
                     }
 
                     if ((!Double.isNaN(previousEventTime)) &&
-                        (AccurateMath.abs(root - ta) <= convergence) &&
-                        (AccurateMath.abs(root - previousEventTime) <= convergence)) {
+                        (JdkMath.abs(root - ta) <= convergence) &&
+                        (JdkMath.abs(root - previousEventTime) <= convergence)) {
                         // we have either found nothing or found (again ?) a past event,
                         // retry the substep excluding this value, and taking care to have the
                         // required sign in case the g function is noisy around its zero and
@@ -311,7 +311,7 @@
                             return true;
                         }
                     } else if (Double.isNaN(previousEventTime) ||
-                               (AccurateMath.abs(previousEventTime - root) > convergence)) {
+                               (JdkMath.abs(previousEventTime - root) > convergence)) {
                         pendingEventTime = root;
                         pendingEvent = true;
                         return true;
@@ -361,7 +361,7 @@
         t0 = t;
         g0 = handler.g(t, y);
 
-        if (pendingEvent && (AccurateMath.abs(pendingEventTime - t) <= convergence)) {
+        if (pendingEvent && (JdkMath.abs(pendingEventTime - t) <= convergence)) {
             // force the sign to its value "just after the event"
             previousEventTime = t;
             g0Positive        = increasing;
@@ -389,7 +389,7 @@
      */
     public boolean reset(final double t, final double[] y) {
 
-        if (!(pendingEvent && (AccurateMath.abs(pendingEventTime - t) <= convergence))) {
+        if (!(pendingEvent && (JdkMath.abs(pendingEventTime - t) <= convergence))) {
             return false;
         }
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/events/FieldEventState.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/events/FieldEventState.java
index e91bacc..d7e523b 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/events/FieldEventState.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/events/FieldEventState.java
@@ -26,7 +26,7 @@
 import org.apache.commons.math4.legacy.ode.FieldODEState;
 import org.apache.commons.math4.legacy.ode.FieldODEStateAndDerivative;
 import org.apache.commons.math4.legacy.ode.sampling.FieldStepInterpolator;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /** This class handles the state for one {@link EventHandler
  * event handler} during integration steps.
@@ -171,8 +171,8 @@
 
             // extremely rare case: there is a zero EXACTLY at interval start
             // we will use the sign slightly after step beginning to force ignoring this zero
-            final double epsilon = AccurateMath.max(solver.getAbsoluteAccuracy().getReal(),
-                                                AccurateMath.abs(solver.getRelativeAccuracy().multiply(t0).getReal()));
+            final double epsilon = JdkMath.max(solver.getAbsoluteAccuracy().getReal(),
+                                                JdkMath.abs(solver.getRelativeAccuracy().multiply(t0).getReal()));
             final T tStart = t0.add(0.5 * epsilon);
             g0 = handler.g(interpolator.getInterpolatedState(tStart));
         }
@@ -199,7 +199,7 @@
             // we cannot do anything on such a small step, don't trigger any events
             return false;
         }
-        final int n = AccurateMath.max(1, (int) AccurateMath.ceil(AccurateMath.abs(dt.getReal()) / maxCheckInterval));
+        final int n = JdkMath.max(1, (int) JdkMath.ceil(JdkMath.abs(dt.getReal()) / maxCheckInterval));
         final T   h = dt.divide(n);
 
         final RealFieldUnivariateFunction<T> f = new RealFieldUnivariateFunction<T>() {
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/events/Transformer.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/events/Transformer.java
index c2e005f..b4b2a51 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/events/Transformer.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/events/Transformer.java
@@ -17,7 +17,7 @@
 
 package org.apache.commons.math4.legacy.ode.events;
 
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.numbers.core.Precision;
 
 
@@ -80,7 +80,7 @@
         /**  {@inheritDoc} */
         @Override
         protected double transformed(final double g) {
-            return AccurateMath.min(-Precision.SAFE_MIN, AccurateMath.min(-g, +g));
+            return JdkMath.min(-Precision.SAFE_MIN, JdkMath.min(-g, +g));
         }
     },
 
@@ -94,7 +94,7 @@
         /**  {@inheritDoc} */
         @Override
         protected double transformed(final double g) {
-            return AccurateMath.max(+Precision.SAFE_MIN, AccurateMath.max(-g, +g));
+            return JdkMath.max(+Precision.SAFE_MIN, JdkMath.max(-g, +g));
         }
     };
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsBashforthIntegrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsBashforthIntegrator.java
index 2cd9ea0..c1ac06c 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsBashforthIntegrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsBashforthIntegrator.java
@@ -26,7 +26,7 @@
 import org.apache.commons.math4.legacy.ode.EquationsMapper;
 import org.apache.commons.math4.legacy.ode.ExpandableStatefulODE;
 import org.apache.commons.math4.legacy.ode.sampling.NordsieckStepInterpolator;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 
 /**
@@ -207,7 +207,7 @@
 
         double error = 0;
         for (int i = 0; i < mainSetDimension; ++i) {
-            final double yScale = AccurateMath.abs(predictedState[i]);
+            final double yScale = JdkMath.abs(predictedState[i]);
             final double tol = (vecAbsoluteTolerance == null) ?
                                (scalAbsoluteTolerance + scalRelativeTolerance * yScale) :
                                (vecAbsoluteTolerance[i] + vecRelativeTolerance[i] * yScale);
@@ -227,7 +227,7 @@
 
         }
 
-        return AccurateMath.sqrt(error / mainSetDimension);
+        return JdkMath.sqrt(error / mainSetDimension);
 
     }
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsMoultonIntegrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsMoultonIntegrator.java
index ed6be46..20b05db 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsMoultonIntegrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsMoultonIntegrator.java
@@ -28,7 +28,7 @@
 import org.apache.commons.math4.legacy.ode.EquationsMapper;
 import org.apache.commons.math4.legacy.ode.ExpandableStatefulODE;
 import org.apache.commons.math4.legacy.ode.sampling.NordsieckStepInterpolator;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 
 /**
@@ -406,7 +406,7 @@
             for (int i = 0; i < after.length; ++i) {
                 after[i] += previous[i] + scaled[i];
                 if (i < mainSetDimension) {
-                    final double yScale = AccurateMath.max(AccurateMath.abs(previous[i]), AccurateMath.abs(after[i]));
+                    final double yScale = JdkMath.max(JdkMath.abs(previous[i]), JdkMath.abs(after[i]));
                     final double tol    = (vecAbsoluteTolerance == null) ?
                                           (scalAbsoluteTolerance + scalRelativeTolerance * yScale) :
                                           (vecAbsoluteTolerance[i] + vecRelativeTolerance[i] * yScale);
@@ -415,7 +415,7 @@
                 }
             }
 
-            return AccurateMath.sqrt(error / mainSetDimension);
+            return JdkMath.sqrt(error / mainSetDimension);
 
         }
     }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/AdaptiveStepsizeFieldIntegrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/AdaptiveStepsizeFieldIntegrator.java
index c136245..0f8dfae 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/AdaptiveStepsizeFieldIntegrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/AdaptiveStepsizeFieldIntegrator.java
@@ -27,7 +27,7 @@
 import org.apache.commons.math4.legacy.ode.FieldEquationsMapper;
 import org.apache.commons.math4.legacy.ode.FieldODEState;
 import org.apache.commons.math4.legacy.ode.FieldODEStateAndDerivative;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 
 /**
@@ -159,8 +159,8 @@
                                    final double absoluteTolerance,
                                    final double relativeTolerance) {
 
-        minStep     = getField().getZero().add(AccurateMath.abs(minimalStep));
-        maxStep     = getField().getZero().add(AccurateMath.abs(maximalStep));
+        minStep     = getField().getZero().add(JdkMath.abs(minimalStep));
+        maxStep     = getField().getZero().add(JdkMath.abs(maximalStep));
         initialStep = getField().getOne().negate();
 
         scalAbsoluteTolerance = absoluteTolerance;
@@ -188,8 +188,8 @@
                                    final double[] absoluteTolerance,
                                    final double[] relativeTolerance) {
 
-        minStep     = getField().getZero().add(AccurateMath.abs(minimalStep));
-        maxStep     = getField().getZero().add(AccurateMath.abs(maximalStep));
+        minStep     = getField().getZero().add(JdkMath.abs(minimalStep));
+        maxStep     = getField().getZero().add(JdkMath.abs(maximalStep));
         initialStep = getField().getOne().negate();
 
         scalAbsoluteTolerance = 0;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/AdaptiveStepsizeIntegrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/AdaptiveStepsizeIntegrator.java
index ef4307d..38457cb 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/AdaptiveStepsizeIntegrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/AdaptiveStepsizeIntegrator.java
@@ -24,7 +24,7 @@
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
 import org.apache.commons.math4.legacy.ode.AbstractIntegrator;
 import org.apache.commons.math4.legacy.ode.ExpandableStatefulODE;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * This abstract class holds the common part of all adaptive
@@ -153,8 +153,8 @@
                                  final double absoluteTolerance,
                                  final double relativeTolerance) {
 
-      minStep     = AccurateMath.abs(minimalStep);
-      maxStep     = AccurateMath.abs(maximalStep);
+      minStep     = JdkMath.abs(minimalStep);
+      maxStep     = JdkMath.abs(maximalStep);
       initialStep = -1;
 
       scalAbsoluteTolerance = absoluteTolerance;
@@ -182,8 +182,8 @@
                                  final double[] absoluteTolerance,
                                  final double[] relativeTolerance) {
 
-      minStep     = AccurateMath.abs(minimalStep);
-      maxStep     = AccurateMath.abs(maximalStep);
+      minStep     = JdkMath.abs(minimalStep);
+      maxStep     = JdkMath.abs(maximalStep);
       initialStep = -1;
 
       scalAbsoluteTolerance = 0;
@@ -267,7 +267,7 @@
     }
 
     double h = ((yOnScale2 < 1.0e-10) || (yDotOnScale2 < 1.0e-10)) ?
-               1.0e-6 : (0.01 * AccurateMath.sqrt(yOnScale2 / yDotOnScale2));
+               1.0e-6 : (0.01 * JdkMath.sqrt(yOnScale2 / yDotOnScale2));
     if (! forward) {
       h = -h;
     }
@@ -284,16 +284,16 @@
       ratio         = (yDot1[j] - yDot0[j]) / scale[j];
       yDDotOnScale += ratio * ratio;
     }
-    yDDotOnScale = AccurateMath.sqrt(yDDotOnScale) / h;
+    yDDotOnScale = JdkMath.sqrt(yDDotOnScale) / h;
 
     // step size is computed such that
     // h^order * max (||y'/tol||, ||y''/tol||) = 0.01
-    final double maxInv2 = AccurateMath.max(AccurateMath.sqrt(yDotOnScale2), yDDotOnScale);
+    final double maxInv2 = JdkMath.max(JdkMath.sqrt(yDotOnScale2), yDDotOnScale);
     final double h1 = (maxInv2 < 1.0e-15) ?
-                      AccurateMath.max(1.0e-6, 0.001 * AccurateMath.abs(h)) :
-                      AccurateMath.pow(0.01 / maxInv2, 1.0 / order);
-    h = AccurateMath.min(100.0 * AccurateMath.abs(h), h1);
-    h = AccurateMath.max(h, 1.0e-12 * AccurateMath.abs(t0));  // avoids cancellation when computing t1 - t0
+                      JdkMath.max(1.0e-6, 0.001 * JdkMath.abs(h)) :
+                      JdkMath.pow(0.01 / maxInv2, 1.0 / order);
+    h = JdkMath.min(100.0 * JdkMath.abs(h), h1);
+    h = JdkMath.max(h, 1.0e-12 * JdkMath.abs(t0));  // avoids cancellation when computing t1 - t0
     if (h < getMinStep()) {
       h = getMinStep();
     }
@@ -321,12 +321,12 @@
     throws NumberIsTooSmallException {
 
       double filteredH = h;
-      if (AccurateMath.abs(h) < minStep) {
+      if (JdkMath.abs(h) < minStep) {
           if (acceptSmall) {
               filteredH = forward ? minStep : -minStep;
           } else {
               throw new NumberIsTooSmallException(LocalizedFormats.MINIMAL_STEPSIZE_REACHED_DURING_INTEGRATION,
-                                                  AccurateMath.abs(h), minStep, true);
+                                                  JdkMath.abs(h), minStep, true);
           }
       }
 
@@ -355,7 +355,7 @@
   /** Reset internal state to dummy values. */
   protected void resetInternalState() {
     stepStart = Double.NaN;
-    stepSize  = AccurateMath.sqrt(minStep * maxStep);
+    stepSize  = JdkMath.sqrt(minStep * maxStep);
   }
 
   /** Get the minimal step.
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince54Integrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince54Integrator.java
index da618b7..efe5a7e 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince54Integrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince54Integrator.java
@@ -17,7 +17,7 @@
 
 package org.apache.commons.math4.legacy.ode.nonstiff;
 
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 
 /**
@@ -145,7 +145,7 @@
                               E4 * yDotK[3][j] +  E5 * yDotK[4][j] +
                               E6 * yDotK[5][j] +  E7 * yDotK[6][j];
 
-        final double yScale = AccurateMath.max(AccurateMath.abs(y0[j]), AccurateMath.abs(y1[j]));
+        final double yScale = JdkMath.max(JdkMath.abs(y0[j]), JdkMath.abs(y1[j]));
         final double tol = (vecAbsoluteTolerance == null) ?
                            (scalAbsoluteTolerance + scalRelativeTolerance * yScale) :
                                (vecAbsoluteTolerance[j] + vecRelativeTolerance[j] * yScale);
@@ -154,7 +154,7 @@
 
     }
 
-    return AccurateMath.sqrt(error / mainSetDimension);
+    return JdkMath.sqrt(error / mainSetDimension);
 
   }
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince853Integrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince853Integrator.java
index 6643228..6c66964 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince853Integrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince853Integrator.java
@@ -17,7 +17,7 @@
 
 package org.apache.commons.math4.legacy.ode.nonstiff;
 
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 
 /**
@@ -60,8 +60,8 @@
 
   /** Time steps Butcher array. */
   private static final double[] STATIC_C = {
-    (12.0 - 2.0 * AccurateMath.sqrt(6.0)) / 135.0, (6.0 - AccurateMath.sqrt(6.0)) / 45.0, (6.0 - AccurateMath.sqrt(6.0)) / 30.0,
-    (6.0 + AccurateMath.sqrt(6.0)) / 30.0, 1.0/3.0, 1.0/4.0, 4.0/13.0, 127.0/195.0, 3.0/5.0,
+    (12.0 - 2.0 * JdkMath.sqrt(6.0)) / 135.0, (6.0 - JdkMath.sqrt(6.0)) / 45.0, (6.0 - JdkMath.sqrt(6.0)) / 30.0,
+    (6.0 + JdkMath.sqrt(6.0)) / 30.0, 1.0/3.0, 1.0/4.0, 4.0/13.0, 127.0/195.0, 3.0/5.0,
     6.0/7.0, 1.0, 1.0
   };
 
@@ -69,55 +69,55 @@
   private static final double[][] STATIC_A = {
 
     // k2
-    {(12.0 - 2.0 * AccurateMath.sqrt(6.0)) / 135.0},
+    {(12.0 - 2.0 * JdkMath.sqrt(6.0)) / 135.0},
 
     // k3
-    {(6.0 - AccurateMath.sqrt(6.0)) / 180.0, (6.0 - AccurateMath.sqrt(6.0)) / 60.0},
+    {(6.0 - JdkMath.sqrt(6.0)) / 180.0, (6.0 - JdkMath.sqrt(6.0)) / 60.0},
 
     // k4
-    {(6.0 - AccurateMath.sqrt(6.0)) / 120.0, 0.0, (6.0 - AccurateMath.sqrt(6.0)) / 40.0},
+    {(6.0 - JdkMath.sqrt(6.0)) / 120.0, 0.0, (6.0 - JdkMath.sqrt(6.0)) / 40.0},
 
     // k5
-    {(462.0 + 107.0 * AccurateMath.sqrt(6.0)) / 3000.0, 0.0,
-     (-402.0 - 197.0 * AccurateMath.sqrt(6.0)) / 1000.0, (168.0 + 73.0 * AccurateMath.sqrt(6.0)) / 375.0},
+    {(462.0 + 107.0 * JdkMath.sqrt(6.0)) / 3000.0, 0.0,
+     (-402.0 - 197.0 * JdkMath.sqrt(6.0)) / 1000.0, (168.0 + 73.0 * JdkMath.sqrt(6.0)) / 375.0},
 
     // k6
-    {1.0 / 27.0, 0.0, 0.0, (16.0 + AccurateMath.sqrt(6.0)) / 108.0, (16.0 - AccurateMath.sqrt(6.0)) / 108.0},
+    {1.0 / 27.0, 0.0, 0.0, (16.0 + JdkMath.sqrt(6.0)) / 108.0, (16.0 - JdkMath.sqrt(6.0)) / 108.0},
 
     // k7
-    {19.0 / 512.0, 0.0, 0.0, (118.0 + 23.0 * AccurateMath.sqrt(6.0)) / 1024.0,
-     (118.0 - 23.0 * AccurateMath.sqrt(6.0)) / 1024.0, -9.0 / 512.0},
+    {19.0 / 512.0, 0.0, 0.0, (118.0 + 23.0 * JdkMath.sqrt(6.0)) / 1024.0,
+     (118.0 - 23.0 * JdkMath.sqrt(6.0)) / 1024.0, -9.0 / 512.0},
 
     // k8
-    {13772.0 / 371293.0, 0.0, 0.0, (51544.0 + 4784.0 * AccurateMath.sqrt(6.0)) / 371293.0,
-     (51544.0 - 4784.0 * AccurateMath.sqrt(6.0)) / 371293.0, -5688.0 / 371293.0, 3072.0 / 371293.0},
+    {13772.0 / 371293.0, 0.0, 0.0, (51544.0 + 4784.0 * JdkMath.sqrt(6.0)) / 371293.0,
+     (51544.0 - 4784.0 * JdkMath.sqrt(6.0)) / 371293.0, -5688.0 / 371293.0, 3072.0 / 371293.0},
 
     // k9
     {58656157643.0 / 93983540625.0, 0.0, 0.0,
-     (-1324889724104.0 - 318801444819.0 * AccurateMath.sqrt(6.0)) / 626556937500.0,
-     (-1324889724104.0 + 318801444819.0 * AccurateMath.sqrt(6.0)) / 626556937500.0,
+     (-1324889724104.0 - 318801444819.0 * JdkMath.sqrt(6.0)) / 626556937500.0,
+     (-1324889724104.0 + 318801444819.0 * JdkMath.sqrt(6.0)) / 626556937500.0,
      96044563816.0 / 3480871875.0, 5682451879168.0 / 281950621875.0,
      -165125654.0 / 3796875.0},
 
     // k10
     {8909899.0 / 18653125.0, 0.0, 0.0,
-     (-4521408.0 - 1137963.0 * AccurateMath.sqrt(6.0)) / 2937500.0,
-     (-4521408.0 + 1137963.0 * AccurateMath.sqrt(6.0)) / 2937500.0,
+     (-4521408.0 - 1137963.0 * JdkMath.sqrt(6.0)) / 2937500.0,
+     (-4521408.0 + 1137963.0 * JdkMath.sqrt(6.0)) / 2937500.0,
      96663078.0 / 4553125.0, 2107245056.0 / 137915625.0,
      -4913652016.0 / 147609375.0, -78894270.0 / 3880452869.0},
 
     // k11
     {-20401265806.0 / 21769653311.0, 0.0, 0.0,
-     (354216.0 + 94326.0 * AccurateMath.sqrt(6.0)) / 112847.0,
-     (354216.0 - 94326.0 * AccurateMath.sqrt(6.0)) / 112847.0,
+     (354216.0 + 94326.0 * JdkMath.sqrt(6.0)) / 112847.0,
+     (354216.0 - 94326.0 * JdkMath.sqrt(6.0)) / 112847.0,
      -43306765128.0 / 5313852383.0, -20866708358144.0 / 1126708119789.0,
      14886003438020.0 / 654632330667.0, 35290686222309375.0 / 14152473387134411.0,
      -1477884375.0 / 485066827.0},
 
     // k12
     {39815761.0 / 17514443.0, 0.0, 0.0,
-     (-3457480.0 - 960905.0 * AccurateMath.sqrt(6.0)) / 551636.0,
-     (-3457480.0 + 960905.0 * AccurateMath.sqrt(6.0)) / 551636.0,
+     (-3457480.0 - 960905.0 * JdkMath.sqrt(6.0)) / 551636.0,
+     (-3457480.0 + 960905.0 * JdkMath.sqrt(6.0)) / 551636.0,
      -844554132.0 / 47026969.0, 8444996352.0 / 302158619.0,
      -2509602342.0 / 877790785.0, -28388795297996250.0 / 3199510091356783.0,
      226716250.0 / 18341897.0, 1371316744.0 / 2131383595.0},
@@ -264,7 +264,7 @@
                              E2_09 * yDotK[8][j]  + E2_10 * yDotK[9][j] +
                              E2_11 * yDotK[10][j] + E2_12 * yDotK[11][j];
 
-      final double yScale = AccurateMath.max(AccurateMath.abs(y0[j]), AccurateMath.abs(y1[j]));
+      final double yScale = JdkMath.max(JdkMath.abs(y0[j]), JdkMath.abs(y1[j]));
       final double tol = (vecAbsoluteTolerance == null) ?
                          (scalAbsoluteTolerance + scalRelativeTolerance * yScale) :
                          (vecAbsoluteTolerance[j] + vecRelativeTolerance[j] * yScale);
@@ -279,7 +279,7 @@
       den = 1.0;
     }
 
-    return AccurateMath.abs(h) * error1 / AccurateMath.sqrt(mainSetDimension * den);
+    return JdkMath.abs(h) * error1 / JdkMath.sqrt(mainSetDimension * den);
 
   }
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/EmbeddedRungeKuttaIntegrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/EmbeddedRungeKuttaIntegrator.java
index 49068a3..f2d593d 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/EmbeddedRungeKuttaIntegrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/EmbeddedRungeKuttaIntegrator.java
@@ -22,7 +22,7 @@
 import org.apache.commons.math4.legacy.exception.NoBracketingException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
 import org.apache.commons.math4.legacy.ode.ExpandableStatefulODE;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * This class implements the common part of all embedded Runge-Kutta
@@ -235,11 +235,11 @@
           final double[] scale = new double[mainSetDimension];
           if (vecAbsoluteTolerance == null) {
               for (int i = 0; i < scale.length; ++i) {
-                scale[i] = scalAbsoluteTolerance + scalRelativeTolerance * AccurateMath.abs(y[i]);
+                scale[i] = scalAbsoluteTolerance + scalRelativeTolerance * JdkMath.abs(y[i]);
               }
           } else {
               for (int i = 0; i < scale.length; ++i) {
-                scale[i] = vecAbsoluteTolerance[i] + vecRelativeTolerance[i] * AccurateMath.abs(y[i]);
+                scale[i] = vecAbsoluteTolerance[i] + vecRelativeTolerance[i] * JdkMath.abs(y[i]);
               }
           }
           hNew = initializeStep(forward, getOrder(), scale,
@@ -287,8 +287,8 @@
         if (error >= 1.0) {
           // reject the step and attempt to reduce error by stepsize control
           final double factor =
-              AccurateMath.min(maxGrowth,
-                           AccurateMath.max(minReduction, safety * AccurateMath.pow(error, exp)));
+              JdkMath.min(maxGrowth,
+                           JdkMath.max(minReduction, safety * JdkMath.pow(error, exp)));
           hNew = filterStep(stepSize * factor, forward, false);
         }
 
@@ -313,7 +313,7 @@
 
           // stepsize control for next step
           final double factor =
-              AccurateMath.min(maxGrowth, AccurateMath.max(minReduction, safety * AccurateMath.pow(error, exp)));
+              JdkMath.min(maxGrowth, JdkMath.max(minReduction, safety * JdkMath.pow(error, exp)));
           final double  scaledH    = stepSize * factor;
           final double  nextT      = stepStart + scaledH;
           final boolean nextIsLast = forward ? (nextT >= t) : (nextT <= t);
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/GillIntegrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/GillIntegrator.java
index 7c584ed..e5a1832 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/GillIntegrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/GillIntegrator.java
@@ -17,7 +17,7 @@
 
 package org.apache.commons.math4.legacy.ode.nonstiff;
 
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 
 /**
@@ -54,13 +54,13 @@
   /** Internal weights Butcher array. */
   private static final double[][] STATIC_A = {
     { 1.0 / 2.0 },
-    { (AccurateMath.sqrt(2.0) - 1.0) / 2.0, (2.0 - AccurateMath.sqrt(2.0)) / 2.0 },
-    { 0.0, -AccurateMath.sqrt(2.0) / 2.0, (2.0 + AccurateMath.sqrt(2.0)) / 2.0 }
+    { (JdkMath.sqrt(2.0) - 1.0) / 2.0, (2.0 - JdkMath.sqrt(2.0)) / 2.0 },
+    { 0.0, -JdkMath.sqrt(2.0) / 2.0, (2.0 + JdkMath.sqrt(2.0)) / 2.0 }
   };
 
   /** Propagation weights Butcher array. */
   private static final double[] STATIC_B = {
-    1.0 / 6.0, (2.0 - AccurateMath.sqrt(2.0)) / 6.0, (2.0 + AccurateMath.sqrt(2.0)) / 6.0, 1.0 / 6.0
+    1.0 / 6.0, (2.0 - JdkMath.sqrt(2.0)) / 6.0, (2.0 + JdkMath.sqrt(2.0)) / 6.0, 1.0 / 6.0
   };
 
   /** Simple constructor.
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/GillStepInterpolator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/GillStepInterpolator.java
index 87b82aa..71b77c2 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/GillStepInterpolator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/GillStepInterpolator.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.ode.nonstiff;
 
 import org.apache.commons.math4.legacy.ode.sampling.StepInterpolator;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * This class implements a step interpolator for the Gill fourth
@@ -55,10 +55,10 @@
   extends RungeKuttaStepInterpolator {
 
     /** First Gill coefficient. */
-    private static final double ONE_MINUS_INV_SQRT_2 = 1 - AccurateMath.sqrt(0.5);
+    private static final double ONE_MINUS_INV_SQRT_2 = 1 - JdkMath.sqrt(0.5);
 
     /** Second Gill coefficient. */
-    private static final double ONE_PLUS_INV_SQRT_2 = 1 + AccurateMath.sqrt(0.5);
+    private static final double ONE_PLUS_INV_SQRT_2 = 1 + JdkMath.sqrt(0.5);
 
     /** Serializable version identifier. */
     private static final long serialVersionUID = 20111120L;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/GraggBulirschStoerIntegrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/GraggBulirschStoerIntegrator.java
index e2b0a61..9916e0b 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/GraggBulirschStoerIntegrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/GraggBulirschStoerIntegrator.java
@@ -26,7 +26,7 @@
 import org.apache.commons.math4.legacy.ode.events.EventHandler;
 import org.apache.commons.math4.legacy.ode.sampling.AbstractStepInterpolator;
 import org.apache.commons.math4.legacy.ode.sampling.StepHandler;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * This class implements a Gragg-Bulirsch-Stoer integrator for
@@ -425,12 +425,12 @@
   private void rescale(final double[] y1, final double[] y2, final double[] scale) {
     if (vecAbsoluteTolerance == null) {
       for (int i = 0; i < scale.length; ++i) {
-        final double yi = AccurateMath.max(AccurateMath.abs(y1[i]), AccurateMath.abs(y2[i]));
+        final double yi = JdkMath.max(JdkMath.abs(y1[i]), JdkMath.abs(y2[i]));
         scale[i] = scalAbsoluteTolerance + scalRelativeTolerance * yi;
       }
     } else {
       for (int i = 0; i < scale.length; ++i) {
-        final double yi = AccurateMath.max(AccurateMath.abs(y1[i]), AccurateMath.abs(y2[i]));
+        final double yi = JdkMath.max(JdkMath.abs(y1[i]), JdkMath.abs(y2[i]));
         scale[i] = vecAbsoluteTolerance[i] + vecRelativeTolerance[i] * yi;
       }
     }
@@ -500,7 +500,7 @@
           final double ratio = (f[j+1][l] - f[0][l]) / scale[l];
           deltaNorm += ratio * ratio;
         }
-        if (deltaNorm > 4 * AccurateMath.max(1.0e-15, initialNorm)) {
+        if (deltaNorm > 4 * JdkMath.max(1.0e-15, initialNorm)) {
           return false;
         }
       }
@@ -595,10 +595,10 @@
     // initial order selection
     final double tol =
         (vecRelativeTolerance == null) ? scalRelativeTolerance : vecRelativeTolerance[0];
-    final double log10R = AccurateMath.log10(AccurateMath.max(1.0e-10, tol));
-    int targetIter = AccurateMath.max(1,
-                              AccurateMath.min(sequence.length - 2,
-                                       (int) AccurateMath.floor(0.5 - 0.6 * log10R)));
+    final double log10R = JdkMath.log10(JdkMath.max(1.0e-10, tol));
+    int targetIter = JdkMath.max(1,
+                              JdkMath.min(sequence.length - 2,
+                                       (int) JdkMath.floor(0.5 - 0.6 * log10R)));
 
     // set up an interpolator sharing the integrator arrays
     final AbstractStepInterpolator interpolator =
@@ -665,7 +665,7 @@
                        yTmp)) {
 
           // the stability check failed, we reduce the global step
-          hNew   = AccurateMath.abs(filterStep(stepSize * stabilityReduction, forward, false));
+          hNew   = JdkMath.abs(filterStep(stepSize * stabilityReduction, forward, false));
           reject = true;
           loop   = false;
 
@@ -682,26 +682,26 @@
             // estimate the error at the end of the step.
             error = 0;
             for (int j = 0; j < mainSetDimension; ++j) {
-              final double e = AccurateMath.abs(y1[j] - y1Diag[0][j]) / scale[j];
+              final double e = JdkMath.abs(y1[j] - y1Diag[0][j]) / scale[j];
               error += e * e;
             }
-            error = AccurateMath.sqrt(error / mainSetDimension);
+            error = JdkMath.sqrt(error / mainSetDimension);
 
             if ((error > 1.0e15) || ((k > 1) && (error > maxError))) {
               // error is too big, we reduce the global step
-              hNew   = AccurateMath.abs(filterStep(stepSize * stabilityReduction, forward, false));
+              hNew   = JdkMath.abs(filterStep(stepSize * stabilityReduction, forward, false));
               reject = true;
               loop   = false;
             } else {
 
-              maxError = AccurateMath.max(4 * error, 1.0);
+              maxError = JdkMath.max(4 * error, 1.0);
 
               // compute optimal stepsize for this order
               final double exp = 1.0 / (2 * k + 1);
-              double fac = stepControl2 / AccurateMath.pow(error / stepControl1, exp);
-              final double pow = AccurateMath.pow(stepControl3, exp);
-              fac = AccurateMath.max(pow / stepControl4, AccurateMath.min(1 / pow, fac));
-              optimalStep[k]     = AccurateMath.abs(filterStep(stepSize * fac, forward, true));
+              double fac = stepControl2 / JdkMath.pow(error / stepControl1, exp);
+              final double pow = JdkMath.pow(stepControl3, exp);
+              fac = JdkMath.max(pow / stepControl4, JdkMath.min(1 / pow, fac));
+              optimalStep[k]     = JdkMath.abs(filterStep(stepSize * fac, forward, true));
               costPerTimeUnit[k] = costPerStep[k] / optimalStep[k];
 
               // check convergence
@@ -807,13 +807,13 @@
 
           // derivative at middle point of the step
           final int l2 = l / 2;
-          double factor = AccurateMath.pow(0.5 * sequence[l2], l);
+          double factor = JdkMath.pow(0.5 * sequence[l2], l);
           int middleIndex = fk[l2].length / 2;
           for (int i = 0; i < y0.length; ++i) {
             yMidDots[l+1][i] = factor * fk[l2][middleIndex + l][i];
           }
           for (int j = 1; j <= k - l2; ++j) {
-            factor = AccurateMath.pow(0.5 * sequence[j + l2], l);
+            factor = JdkMath.pow(0.5 * sequence[j + l2], l);
             middleIndex = fk[l2+j].length / 2;
             for (int i = 0; i < y0.length; ++i) {
               diagonal[j-1][i] = factor * fk[l2+j][middleIndex+l][i];
@@ -845,7 +845,7 @@
           if (useInterpolationError) {
             // use the interpolation error to limit stepsize
             final double interpError = gbsInterpolator.estimateError(scale);
-            hInt = AccurateMath.abs(stepSize / AccurateMath.max(AccurateMath.pow(interpError, 1.0 / (mu+4)),
+            hInt = JdkMath.abs(stepSize / JdkMath.max(JdkMath.pow(interpError, 1.0 / (mu+4)),
                                                 0.01));
             if (interpError > 10.0) {
               hNew = hInt;
@@ -880,7 +880,7 @@
           if (costPerTimeUnit[k-1] < orderControl1 * costPerTimeUnit[k]) {
             optimalIter = k-1;
           } else if (costPerTimeUnit[k] < orderControl2 * costPerTimeUnit[k-1]) {
-            optimalIter = AccurateMath.min(k+1, sequence.length - 2);
+            optimalIter = JdkMath.min(k+1, sequence.length - 2);
           }
         } else {
           optimalIter = k - 1;
@@ -889,15 +889,15 @@
             optimalIter = k - 2;
           }
           if (costPerTimeUnit[k] < orderControl2 * costPerTimeUnit[optimalIter]) {
-            optimalIter = AccurateMath.min(k, sequence.length - 2);
+            optimalIter = JdkMath.min(k, sequence.length - 2);
           }
         }
 
         if (previousRejected) {
           // after a rejected step neither order nor stepsize
           // should increase
-          targetIter = AccurateMath.min(optimalIter, k);
-          hNew = AccurateMath.min(AccurateMath.abs(stepSize), optimalStep[targetIter]);
+          targetIter = JdkMath.min(optimalIter, k);
+          hNew = JdkMath.min(JdkMath.abs(stepSize), optimalStep[targetIter]);
         } else {
           // stepsize control
           if (optimalIter <= k) {
@@ -921,7 +921,7 @@
 
       }
 
-      hNew = AccurateMath.min(hNew, hInt);
+      hNew = JdkMath.min(hNew, hInt);
       if (! forward) {
         hNew = -hNew;
       }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/GraggBulirschStoerStepInterpolator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/GraggBulirschStoerStepInterpolator.java
index 3b0963b..41f5de4 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/GraggBulirschStoerStepInterpolator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/GraggBulirschStoerStepInterpolator.java
@@ -24,7 +24,7 @@
 import org.apache.commons.math4.legacy.ode.EquationsMapper;
 import org.apache.commons.math4.legacy.ode.sampling.AbstractStepInterpolator;
 import org.apache.commons.math4.legacy.ode.sampling.StepInterpolator;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * This class implements an interpolator for the Gragg-Bulirsch-Stoer
@@ -216,7 +216,7 @@
         for (int i = 0; i < errfac.length; ++i) {
           final int ip5 = i + 5;
           errfac[i] = 1.0 / (ip5 * ip5);
-          final double e = 0.5 * AccurateMath.sqrt (((double) (i + 1)) / ip5);
+          final double e = 0.5 * JdkMath.sqrt (((double) (i + 1)) / ip5);
           for (int j = 0; j <= i; ++j) {
             errfac[i] *= e / (j + 1);
           }
@@ -306,7 +306,7 @@
         final double e = polynomials[currentDegree][i] / scale[i];
         error += e * e;
       }
-      error = AccurateMath.sqrt(error / scale.length) * errfac[currentDegree - 5];
+      error = JdkMath.sqrt(error / scale.length) * errfac[currentDegree - 5];
     }
     return error;
   }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/HighamHall54Integrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/HighamHall54Integrator.java
index c0a10b9..eaf6fb8 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/HighamHall54Integrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/HighamHall54Integrator.java
@@ -17,7 +17,7 @@
 
 package org.apache.commons.math4.legacy.ode.nonstiff;
 
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 
 /**
@@ -119,7 +119,7 @@
         errSum += STATIC_E[l] * yDotK[l][j];
       }
 
-      final double yScale = AccurateMath.max(AccurateMath.abs(y0[j]), AccurateMath.abs(y1[j]));
+      final double yScale = JdkMath.max(JdkMath.abs(y0[j]), JdkMath.abs(y1[j]));
       final double tol = (vecAbsoluteTolerance == null) ?
                          (scalAbsoluteTolerance + scalRelativeTolerance * yScale) :
                          (vecAbsoluteTolerance[j] + vecRelativeTolerance[j] * yScale);
@@ -128,7 +128,7 @@
 
     }
 
-    return AccurateMath.sqrt(error / mainSetDimension);
+    return JdkMath.sqrt(error / mainSetDimension);
 
   }
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/LutherIntegrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/LutherIntegrator.java
index d538883..7fb3cf0 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/LutherIntegrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/LutherIntegrator.java
@@ -17,7 +17,7 @@
 
 package org.apache.commons.math4.legacy.ode.nonstiff;
 
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 
 /**
@@ -56,7 +56,7 @@
 public class LutherIntegrator extends RungeKuttaIntegrator {
 
     /** Square root. */
-    private static final double Q = AccurateMath.sqrt(21);
+    private static final double Q = JdkMath.sqrt(21);
 
     /** Time steps Butcher array. */
     private static final double[] STATIC_C = {
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/LutherStepInterpolator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/LutherStepInterpolator.java
index 46b6ead..03b9ddb 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/LutherStepInterpolator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/LutherStepInterpolator.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.ode.nonstiff;
 
 import org.apache.commons.math4.legacy.ode.sampling.StepInterpolator;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * This class represents an interpolator over the last step during an
@@ -38,7 +38,7 @@
     private static final long serialVersionUID = 20140416L;
 
     /** Square root. */
-    private static final double Q = AccurateMath.sqrt(21);
+    private static final double Q = JdkMath.sqrt(21);
 
     /** Simple constructor.
      * This constructor builds an instance that is not usable yet, the
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/RungeKuttaIntegrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/RungeKuttaIntegrator.java
index 229ed4d..7c3eb28 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/RungeKuttaIntegrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/nonstiff/RungeKuttaIntegrator.java
@@ -25,7 +25,7 @@
 import org.apache.commons.math4.legacy.ode.AbstractIntegrator;
 import org.apache.commons.math4.legacy.ode.ExpandableStatefulODE;
 import org.apache.commons.math4.legacy.ode.FirstOrderDifferentialEquations;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * This class implements the common part of all fixed step Runge-Kutta
@@ -86,7 +86,7 @@
     this.a          = a;
     this.b          = b;
     this.prototype  = prototype;
-    this.step       = AccurateMath.abs(step);
+    this.step       = JdkMath.abs(step);
   }
 
   /** {@inheritDoc} */
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/sampling/FieldStepNormalizer.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/sampling/FieldStepNormalizer.java
index d97ee34..94cd515 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/sampling/FieldStepNormalizer.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/sampling/FieldStepNormalizer.java
@@ -20,7 +20,7 @@
 import org.apache.commons.math4.legacy.core.RealFieldElement;
 import org.apache.commons.math4.legacy.exception.MaxCountExceededException;
 import org.apache.commons.math4.legacy.ode.FieldODEStateAndDerivative;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.numbers.core.Precision;
 
 /**
@@ -156,7 +156,7 @@
      */
     public FieldStepNormalizer(final double h, final FieldFixedStepHandler<T> handler,
                                final StepNormalizerMode mode, final StepNormalizerBounds bounds) {
-        this.h       = AccurateMath.abs(h);
+        this.h       = JdkMath.abs(h);
         this.handler = handler;
         this.mode    = mode;
         this.bounds  = bounds;
@@ -210,7 +210,7 @@
         // Calculate next normalized step time.
         T nextTime = (mode == StepNormalizerMode.INCREMENT) ?
                      last.getTime().add(h) :
-                     last.getTime().getField().getZero().add((AccurateMath.floor(last.getTime().getReal() / h) + 1) * h);
+                     last.getTime().getField().getZero().add((JdkMath.floor(last.getTime().getReal() / h) + 1) * h);
         if (mode == StepNormalizerMode.MULTIPLES &&
             Precision.equals(nextTime.getReal(), last.getTime().getReal(), 1)) {
             nextTime = nextTime.add(h);
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/sampling/NordsieckStepInterpolator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/sampling/NordsieckStepInterpolator.java
index 1faffa2..aa1b8ae 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/sampling/NordsieckStepInterpolator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/sampling/NordsieckStepInterpolator.java
@@ -25,7 +25,7 @@
 import org.apache.commons.math4.legacy.exception.MaxCountExceededException;
 import org.apache.commons.math4.legacy.linear.Array2DRowRealMatrix;
 import org.apache.commons.math4.legacy.ode.EquationsMapper;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * This class implements an interpolator for integrators using Nordsieck representation.
@@ -200,7 +200,7 @@
         for (int i = nData.length - 1; i >= 0; --i) {
             final int order = i + 2;
             final double[] nDataI = nData[i];
-            final double power = AccurateMath.pow(normalizedAbscissa, order);
+            final double power = JdkMath.pow(normalizedAbscissa, order);
             for (int j = 0; j < nDataI.length; ++j) {
                 final double d = nDataI[j] * power;
                 stateVariation[j]          += d;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/sampling/StepNormalizer.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/sampling/StepNormalizer.java
index 6d58d61..636d9ee 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/sampling/StepNormalizer.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/ode/sampling/StepNormalizer.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.ode.sampling;
 
 import org.apache.commons.math4.legacy.exception.MaxCountExceededException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.numbers.core.Precision;
 
 /**
@@ -159,7 +159,7 @@
     public StepNormalizer(final double h, final FixedStepHandler handler,
                           final StepNormalizerMode mode,
                           final StepNormalizerBounds bounds) {
-        this.h          = AccurateMath.abs(h);
+        this.h          = JdkMath.abs(h);
         this.handler    = handler;
         this.mode       = mode;
         this.bounds     = bounds;
@@ -219,7 +219,7 @@
         // Calculate next normalized step time.
         double nextTime = (mode == StepNormalizerMode.INCREMENT) ?
                           lastTime + h :
-                          (AccurateMath.floor(lastTime / h) + 1) * h;
+                          (JdkMath.floor(lastTime / h) + 1) * h;
         if (mode == StepNormalizerMode.MULTIPLES &&
             Precision.equals(nextTime, lastTime, 1)) {
             nextTime += h;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/SimplePointChecker.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/SimplePointChecker.java
index 7906dda..c35d70b 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/SimplePointChecker.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/SimplePointChecker.java
@@ -17,7 +17,7 @@
 package org.apache.commons.math4.legacy.optim;
 
 import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.Pair;
 
 /**
@@ -121,8 +121,8 @@
         for (int i = 0; i < p.length; ++i) {
             final double pi = p[i];
             final double ci = c[i];
-            final double difference = AccurateMath.abs(pi - ci);
-            final double size = AccurateMath.max(AccurateMath.abs(pi), AccurateMath.abs(ci));
+            final double difference = JdkMath.abs(pi - ci);
+            final double size = JdkMath.max(JdkMath.abs(pi), JdkMath.abs(ci));
             if (difference > size * getRelativeThreshold() &&
                 difference > getAbsoluteThreshold()) {
                 return false;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/SimpleValueChecker.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/SimpleValueChecker.java
index e621d36..3e3421e 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/SimpleValueChecker.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/SimpleValueChecker.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.optim;
 
 import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Simple implementation of the {@link ConvergenceChecker} interface using
@@ -117,8 +117,8 @@
 
         final double p = previous.getValue();
         final double c = current.getValue();
-        final double difference = AccurateMath.abs(p - c);
-        final double size = AccurateMath.max(AccurateMath.abs(p), AccurateMath.abs(c));
+        final double difference = JdkMath.abs(p - c);
+        final double size = JdkMath.max(JdkMath.abs(p), JdkMath.abs(c));
         return difference <= size * getRelativeThreshold() ||
             difference <= getAbsoluteThreshold();
     }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/SimpleVectorValueChecker.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/SimpleVectorValueChecker.java
index 200711c..1ce82b0 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/SimpleVectorValueChecker.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/SimpleVectorValueChecker.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.optim;
 
 import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Simple implementation of the {@link ConvergenceChecker} interface using
@@ -122,8 +122,8 @@
         for (int i = 0; i < p.length; ++i) {
             final double pi         = p[i];
             final double ci         = c[i];
-            final double difference = AccurateMath.abs(pi - ci);
-            final double size       = AccurateMath.max(AccurateMath.abs(pi), AccurateMath.abs(ci));
+            final double difference = JdkMath.abs(pi - ci);
+            final double size       = JdkMath.max(JdkMath.abs(pi), JdkMath.abs(ci));
             if (difference > size * getRelativeThreshold() &&
                 difference > getAbsoluteThreshold()) {
                 return false;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/linear/SimplexSolver.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/linear/SimplexSolver.java
index b729710..91b8d7e 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/linear/SimplexSolver.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/linear/SimplexSolver.java
@@ -22,7 +22,7 @@
 import org.apache.commons.math4.legacy.exception.TooManyIterationsException;
 import org.apache.commons.math4.legacy.optim.OptimizationData;
 import org.apache.commons.math4.legacy.optim.PointValuePair;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.numbers.core.Precision;
 
 /**
@@ -256,7 +256,7 @@
             // only consider pivot elements larger than the cutOff threshold
             // selecting others may lead to degeneracy or numerical instabilities
             if (Precision.compareTo(entry, 0d, cutOff) > 0) {
-                final double ratio = AccurateMath.abs(rhs / entry);
+                final double ratio = JdkMath.abs(rhs / entry);
                 // check if the entry is strictly equal to the current min ratio
                 // do not use a ulp/epsilon check
                 final int cmp = Double.compare(ratio, minRatio);
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultivariateFunctionMappingAdapter.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultivariateFunctionMappingAdapter.java
index c1008ab..46a96fa 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultivariateFunctionMappingAdapter.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultivariateFunctionMappingAdapter.java
@@ -23,7 +23,7 @@
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * <p>Adapter for mapping bounded {@link MultivariateFunction} to unbounded ones.</p>
@@ -232,13 +232,13 @@
         /** {@inheritDoc} */
         @Override
         public double unboundedToBounded(final double y) {
-            return lower + AccurateMath.exp(y);
+            return lower + JdkMath.exp(y);
         }
 
         /** {@inheritDoc} */
         @Override
         public double boundedToUnbounded(final double x) {
-            return AccurateMath.log(x - lower);
+            return JdkMath.log(x - lower);
         }
 
     }
@@ -259,13 +259,13 @@
         /** {@inheritDoc} */
         @Override
         public double unboundedToBounded(final double y) {
-            return upper - AccurateMath.exp(-y);
+            return upper - JdkMath.exp(-y);
         }
 
         /** {@inheritDoc} */
         @Override
         public double boundedToUnbounded(final double x) {
-            return -AccurateMath.log(upper - x);
+            return -JdkMath.log(upper - x);
         }
 
     }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultivariateFunctionPenaltyAdapter.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultivariateFunctionPenaltyAdapter.java
index 910c36b..bbeea7e 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultivariateFunctionPenaltyAdapter.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/MultivariateFunctionPenaltyAdapter.java
@@ -20,7 +20,7 @@
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * <p>Adapter extending bounded {@link MultivariateFunction} to an unbouded
@@ -174,7 +174,7 @@
                     } else {
                         overshoot = 0;
                     }
-                    sum += AccurateMath.sqrt(overshoot);
+                    sum += JdkMath.sqrt(overshoot);
                 }
                 return offset + sum;
             }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/BOBYQAOptimizer.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/BOBYQAOptimizer.java
index 4b2ad12..3365282 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/BOBYQAOptimizer.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/BOBYQAOptimizer.java
@@ -27,7 +27,7 @@
 import org.apache.commons.math4.legacy.optim.PointValuePair;
 import org.apache.commons.math4.legacy.optim.nonlinear.scalar.GoalType;
 import org.apache.commons.math4.legacy.optim.nonlinear.scalar.MultivariateOptimizer;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Powell's BOBYQA algorithm. This implementation is translated and
@@ -317,7 +317,7 @@
                     lowerDifference.setEntry(j, -initialTrustRegionRadius);
                     // Computing MAX
                     final double deltaOne = upperBound[j] - currentBest.getEntry(j);
-                    upperDifference.setEntry(j, AccurateMath.max(deltaOne, initialTrustRegionRadius));
+                    upperDifference.setEntry(j, JdkMath.max(deltaOne, initialTrustRegionRadius));
                 }
             } else if (upperDifference.getEntry(j) <= initialTrustRegionRadius) {
                 if (upperDifference.getEntry(j) <= ZERO) {
@@ -329,7 +329,7 @@
                     // Computing MIN
                     final double deltaOne = lowerBound[j] - currentBest.getEntry(j);
                     final double deltaTwo = -initialTrustRegionRadius;
-                    lowerDifference.setEntry(j, AccurateMath.min(deltaOne, deltaTwo));
+                    lowerDifference.setEntry(j, JdkMath.min(deltaOne, deltaTwo));
                     upperDifference.setEntry(j, initialTrustRegionRadius);
                 }
             }
@@ -501,8 +501,8 @@
 
             // Computing MIN
             double deltaOne = delta;
-            double deltaTwo = AccurateMath.sqrt(dsq);
-            dnorm = AccurateMath.min(deltaOne, deltaTwo);
+            double deltaTwo = JdkMath.sqrt(dsq);
+            dnorm = JdkMath.min(deltaOne, deltaTwo);
             if (dnorm < HALF * rho) {
                 ntrits = -1;
                 // Computing 2nd power
@@ -519,8 +519,8 @@
                 // of likely improvements to the model within distance HALF*RHO of XOPT.
 
                 // Computing MAX
-                deltaOne = AccurateMath.max(diffa, diffb);
-                final double errbig = AccurateMath.max(deltaOne, diffc);
+                deltaOne = JdkMath.max(diffa, diffb);
+                final double errbig = JdkMath.max(deltaOne, diffc);
                 final double frhosq = rho * ONE_OVER_EIGHT * rho;
                 if (crvmin > ZERO &&
                     errbig > frhosq * crvmin) {
@@ -794,7 +794,7 @@
                     // Computing MAX
                     // Computing 2nd power
                     final double d4 = distsq / delsq;
-                    final double temp = AccurateMath.max(ONE, d4 * d4);
+                    final double temp = JdkMath.max(ONE, d4 * d4);
                     if (temp * den > scaden) {
                         scaden = temp * den;
                         knew = k;
@@ -803,7 +803,7 @@
                     // Computing MAX
                     // Computing 2nd power
                     final double d5 = lagrangeValuesAtNewPoint.getEntry(k);
-                    biglsq = AccurateMath.max(biglsq, temp * (d5 * d5));
+                    biglsq = JdkMath.max(biglsq, temp * (d5 * d5));
                 }
             }
 
@@ -821,9 +821,9 @@
                 // Computing MAX
                 final double d3 = lowerBound[i];
                 final double d4 = originShift.getEntry(i) + newPoint.getEntry(i);
-                final double d1 = AccurateMath.max(d3, d4);
+                final double d1 = JdkMath.max(d3, d4);
                 final double d2 = upperBound[i];
-                currentBest.setEntry(i, AccurateMath.min(d1, d2));
+                currentBest.setEntry(i, JdkMath.min(d1, d2));
                 if (newPoint.getEntry(i) == lowerDifference.getEntry(i)) {
                     currentBest.setEntry(i, lowerBound[i]);
                 }
@@ -868,7 +868,7 @@
             final double diff = f - fopt - vquad;
             diffc = diffb;
             diffb = diffa;
-            diffa = AccurateMath.abs(diff);
+            diffa = JdkMath.abs(diff);
             if (dnorm > rho) {
                 nfsav = getEvaluations();
             }
@@ -883,13 +883,13 @@
                 final double hDelta = HALF * delta;
                 if (ratio <= ONE_OVER_TEN) {
                     // Computing MIN
-                    delta = AccurateMath.min(hDelta, dnorm);
+                    delta = JdkMath.min(hDelta, dnorm);
                 } else if (ratio <= .7) {
                     // Computing MAX
-                    delta = AccurateMath.max(hDelta, dnorm);
+                    delta = JdkMath.max(hDelta, dnorm);
                 } else {
                     // Computing MAX
-                    delta = AccurateMath.max(hDelta, 2 * dnorm);
+                    delta = JdkMath.max(hDelta, 2 * dnorm);
                 }
                 if (delta <= rho * 1.5) {
                     delta = rho;
@@ -923,7 +923,7 @@
                         // Computing MAX
                         // Computing 2nd power
                         final double d3 = distsq / delsq;
-                        final double temp = AccurateMath.max(ONE, d3 * d3);
+                        final double temp = JdkMath.max(ONE, d3 * d3);
                         if (temp * den > scaden) {
                             scaden = temp * den;
                             knew = k;
@@ -933,7 +933,7 @@
                         // Computing 2nd power
                         final double d4 = lagrangeValuesAtNewPoint.getEntry(k);
                         final double d5 = temp * (d4 * d4);
-                        biglsq = AccurateMath.max(biglsq, d5);
+                        biglsq = JdkMath.max(biglsq, d5);
                     }
                     if (scaden <= HALF * biglsq) {
                         knew = ksav;
@@ -1058,18 +1058,18 @@
                     if (trustRegionCenterOffset.getEntry(i) == lowerDifference.getEntry(i)) {
                         // Computing MIN
                         // Computing 2nd power
-                        final double d1 = AccurateMath.min(ZERO, gradientAtTrustRegionCenter.getEntry(i));
+                        final double d1 = JdkMath.min(ZERO, gradientAtTrustRegionCenter.getEntry(i));
                         gqsq += d1 * d1;
                         // Computing 2nd power
-                        final double d2 = AccurateMath.min(ZERO, sum);
+                        final double d2 = JdkMath.min(ZERO, sum);
                         gisq += d2 * d2;
                     } else if (trustRegionCenterOffset.getEntry(i) == upperDifference.getEntry(i)) {
                         // Computing MAX
                         // Computing 2nd power
-                        final double d1 = AccurateMath.max(ZERO, gradientAtTrustRegionCenter.getEntry(i));
+                        final double d1 = JdkMath.max(ZERO, gradientAtTrustRegionCenter.getEntry(i));
                         gqsq += d1 * d1;
                         // Computing 2nd power
-                        final double d2 = AccurateMath.max(ZERO, sum);
+                        final double d2 = JdkMath.max(ZERO, sum);
                         gisq += d2 * d2;
                     } else {
                         // Computing 2nd power
@@ -1088,7 +1088,7 @@
                     itest = 0;
                 }
                 if (itest >= 3) {
-                    for (int i = 0, max = AccurateMath.max(npt, nh); i < max; i++) {
+                    for (int i = 0, max = JdkMath.max(npt, nh); i < max; i++) {
                         if (i < n) {
                             gradientAtTrustRegionCenter.setEntry(i, lagrangeValuesAtNewPoint.getEntry(npt + i));
                         }
@@ -1122,7 +1122,7 @@
             final double d1 = TWO * delta;
             // Computing 2nd power
             final double d2 = TEN * rho;
-            distsq = AccurateMath.max(d1 * d1, d2 * d2);
+            distsq = JdkMath.max(d1 * d1, d2 * d2);
         }
         case 650: {
             printState(650); // XXX
@@ -1147,10 +1147,10 @@
             // current RHO are complete.
 
             if (knew >= 0) {
-                final double dist = AccurateMath.sqrt(distsq);
+                final double dist = JdkMath.sqrt(distsq);
                 if (ntrits == -1) {
                     // Computing MIN
-                    delta = AccurateMath.min(ONE_OVER_TEN * delta, HALF * dist);
+                    delta = JdkMath.min(ONE_OVER_TEN * delta, HALF * dist);
                     if (delta <= rho * 1.5) {
                         delta = rho;
                     }
@@ -1158,8 +1158,8 @@
                 ntrits = 0;
                 // Computing MAX
                 // Computing MIN
-                final double d1 = AccurateMath.min(ONE_OVER_TEN * dist, delta);
-                adelt = AccurateMath.max(d1, rho);
+                final double d1 = JdkMath.min(ONE_OVER_TEN * dist, delta);
+                adelt = JdkMath.max(d1, rho);
                 dsq = adelt * adelt;
                 state = 90; break;
             }
@@ -1169,7 +1169,7 @@
             if (ratio > ZERO) {
                 state = 60; break;
             }
-            if (AccurateMath.max(delta, dnorm) > rho) {
+            if (JdkMath.max(delta, dnorm) > rho) {
                 state = 60; break;
             }
 
@@ -1184,11 +1184,11 @@
                 if (ratio <= SIXTEEN) {
                     rho = stoppingTrustRegionRadius;
                 } else if (ratio <= TWO_HUNDRED_FIFTY) {
-                    rho = AccurateMath.sqrt(ratio) * stoppingTrustRegionRadius;
+                    rho = JdkMath.sqrt(ratio) * stoppingTrustRegionRadius;
                 } else {
                     rho *= ONE_OVER_TEN;
                 }
-                delta = AccurateMath.max(delta, rho);
+                delta = JdkMath.max(delta, rho);
                 ntrits = 0;
                 nfsav = getEvaluations();
                 state = 60; break;
@@ -1209,9 +1209,9 @@
                     // Computing MAX
                     final double d3 = lowerBound[i];
                     final double d4 = originShift.getEntry(i) + trustRegionCenterOffset.getEntry(i);
-                    final double d1 = AccurateMath.max(d3, d4);
+                    final double d1 = JdkMath.max(d3, d4);
                     final double d2 = upperBound[i];
-                    currentBest.setEntry(i, AccurateMath.min(d1, d2));
+                    currentBest.setEntry(i, JdkMath.min(d1, d2));
                     if (trustRegionCenterOffset.getEntry(i) == lowerDifference.getEntry(i)) {
                         currentBest.setEntry(i, lowerBound[i]);
                     }
@@ -1329,11 +1329,11 @@
                 dderiv += glag.getEntry(i) * tmp;
                 distsq += tmp * tmp;
             }
-            double subd = adelt / AccurateMath.sqrt(distsq);
+            double subd = adelt / JdkMath.sqrt(distsq);
             double slbd = -subd;
             int ilbd = 0;
             int iubd = 0;
-            final double sumin = AccurateMath.min(ONE, subd);
+            final double sumin = JdkMath.min(ONE, subd);
 
             // Revise SLBD and SUBD if necessary because of the bounds in SL and SU.
 
@@ -1346,7 +1346,7 @@
                     }
                     if (subd * tmp > upperDifference.getEntry(i) - trustRegionCenterOffset.getEntry(i)) {
                         // Computing MAX
-                        subd = AccurateMath.max(sumin,
+                        subd = JdkMath.max(sumin,
                                             (upperDifference.getEntry(i) - trustRegionCenterOffset.getEntry(i)) / tmp);
                         iubd = i + 1;
                     }
@@ -1357,7 +1357,7 @@
                     }
                     if (subd * tmp < lowerDifference.getEntry(i) - trustRegionCenterOffset.getEntry(i)) {
                         // Computing MAX
-                        subd = AccurateMath.max(sumin,
+                        subd = JdkMath.max(sumin,
                                             (lowerDifference.getEntry(i) - trustRegionCenterOffset.getEntry(i)) / tmp);
                         iubd = -i - 1;
                     }
@@ -1374,7 +1374,7 @@
                 final double diff = dderiv - ONE;
                 vlag = slbd * (dderiv - slbd * diff);
                 final double d1 = subd * (dderiv - subd * diff);
-                if (AccurateMath.abs(d1) > AccurateMath.abs(vlag)) {
+                if (JdkMath.abs(d1) > JdkMath.abs(vlag)) {
                     step = subd;
                     vlag = d1;
                     isbd = iubd;
@@ -1384,7 +1384,7 @@
                 final double d4 = d2 - diff * subd;
                 if (d3 * d4 < ZERO) {
                     final double d5 = d2 * d2 / diff;
-                    if (AccurateMath.abs(d5) > AccurateMath.abs(vlag)) {
+                    if (JdkMath.abs(d5) > JdkMath.abs(vlag)) {
                         step = d2 / diff;
                         vlag = d5;
                         isbd = 0;
@@ -1396,12 +1396,12 @@
             } else {
                 vlag = slbd * (ONE - slbd);
                 final double tmp = subd * (ONE - subd);
-                if (AccurateMath.abs(tmp) > AccurateMath.abs(vlag)) {
+                if (JdkMath.abs(tmp) > JdkMath.abs(vlag)) {
                     step = subd;
                     vlag = tmp;
                     isbd = iubd;
                 }
-                if (subd > HALF && AccurateMath.abs(vlag) < ONE_OVER_FOUR) {
+                if (subd > HALF && JdkMath.abs(vlag) < ONE_OVER_FOUR) {
                     step = HALF;
                     vlag = ONE_OVER_FOUR;
                     isbd = 0;
@@ -1425,8 +1425,8 @@
 
         for (int i = 0; i < n; i++) {
             final double tmp = trustRegionCenterOffset.getEntry(i) + stpsav * (interpolationPoints.getEntry(ksav, i) - trustRegionCenterOffset.getEntry(i));
-            newPoint.setEntry(i, AccurateMath.max(lowerDifference.getEntry(i),
-                                              AccurateMath.min(upperDifference.getEntry(i), tmp)));
+            newPoint.setEntry(i, JdkMath.max(lowerDifference.getEntry(i),
+                                              JdkMath.min(upperDifference.getEntry(i), tmp)));
         }
         if (ibdsav < 0) {
             newPoint.setEntry(-ibdsav - 1, lowerDifference.getEntry(-ibdsav - 1));
@@ -1449,8 +1449,8 @@
             for (int i = 0; i < n; i++) {
                 final double glagValue = glag.getEntry(i);
                 work1.setEntry(i, ZERO);
-                if (AccurateMath.min(trustRegionCenterOffset.getEntry(i) - lowerDifference.getEntry(i), glagValue) > ZERO ||
-                    AccurateMath.max(trustRegionCenterOffset.getEntry(i) - upperDifference.getEntry(i), glagValue) < ZERO) {
+                if (JdkMath.min(trustRegionCenterOffset.getEntry(i) - lowerDifference.getEntry(i), glagValue) > ZERO ||
+                    JdkMath.max(trustRegionCenterOffset.getEntry(i) - upperDifference.getEntry(i), glagValue) < ZERO) {
                     work1.setEntry(i, bigstp);
                     // Computing 2nd power
                     ggfree += glagValue * glagValue;
@@ -1463,7 +1463,7 @@
             // Investigate whether more components of W can be fixed.
             final double tmp1 = adelt * adelt - wfixsq;
             if (tmp1 > ZERO) {
-                step = AccurateMath.sqrt(tmp1 / ggfree);
+                step = JdkMath.sqrt(tmp1 / ggfree);
                 ggfree = ZERO;
                 for (int i = 0; i < n; i++) {
                     if (work1.getEntry(i) == bigstp) {
@@ -1495,9 +1495,9 @@
                 final double glagValue = glag.getEntry(i);
                 if (work1.getEntry(i) == bigstp) {
                     work1.setEntry(i, -step * glagValue);
-                    final double min = AccurateMath.min(upperDifference.getEntry(i),
+                    final double min = JdkMath.min(upperDifference.getEntry(i),
                                                     trustRegionCenterOffset.getEntry(i) + work1.getEntry(i));
-                    alternativeNewPoint.setEntry(i, AccurateMath.max(lowerDifference.getEntry(i), min));
+                    alternativeNewPoint.setEntry(i, JdkMath.max(lowerDifference.getEntry(i), min));
                 } else if (work1.getEntry(i) == ZERO) {
                     alternativeNewPoint.setEntry(i, trustRegionCenterOffset.getEntry(i));
                 } else if (glagValue > ZERO) {
@@ -1525,12 +1525,12 @@
                 curv = -curv;
             }
             if (curv > -gw &&
-                curv < -gw * (ONE + AccurateMath.sqrt(TWO))) {
+                curv < -gw * (ONE + JdkMath.sqrt(TWO))) {
                 final double scale = -gw / curv;
                 for (int i = 0; i < n; i++) {
                     final double tmp = trustRegionCenterOffset.getEntry(i) + scale * work1.getEntry(i);
-                    alternativeNewPoint.setEntry(i, AccurateMath.max(lowerDifference.getEntry(i),
-                                                    AccurateMath.min(upperDifference.getEntry(i), tmp)));
+                    alternativeNewPoint.setEntry(i, JdkMath.max(lowerDifference.getEntry(i),
+                                                    JdkMath.min(upperDifference.getEntry(i), tmp)));
                 }
                 // Computing 2nd power
                 final double d1 = HALF * gw * scale;
@@ -1649,11 +1649,11 @@
                     stepa = interpolationPoints.getEntry(nfx, nfxm);
                     stepb = -initialTrustRegionRadius;
                     if (lowerDifference.getEntry(nfxm) == ZERO) {
-                        stepb = AccurateMath.min(TWO * initialTrustRegionRadius, upperDifference.getEntry(nfxm));
+                        stepb = JdkMath.min(TWO * initialTrustRegionRadius, upperDifference.getEntry(nfxm));
                         // throw new PathIsExploredException(); // XXX
                     }
                     if (upperDifference.getEntry(nfxm) == ZERO) {
-                        stepb = AccurateMath.max(-TWO * initialTrustRegionRadius, lowerDifference.getEntry(nfxm));
+                        stepb = JdkMath.max(-TWO * initialTrustRegionRadius, lowerDifference.getEntry(nfxm));
                         // throw new PathIsExploredException(); // XXX
                     }
                     interpolationPoints.setEntry(nfm, nfxm, stepb);
@@ -1678,7 +1678,7 @@
             // its index are required.
 
             for (int j = 0; j < n; j++) {
-                currentBest.setEntry(j, AccurateMath.min(AccurateMath.max(lowerBound[j],
+                currentBest.setEntry(j, JdkMath.min(JdkMath.max(lowerBound[j],
                                                                   originShift.getEntry(j) + interpolationPoints.getEntry(nfm, j)),
                                                      upperBound[j]));
                 if (interpolationPoints.getEntry(nfm, j) == lowerDifference.getEntry(j)) {
@@ -1737,9 +1737,9 @@
                     bMatrix.setEntry(nfm, nfxm, -HALF / interpolationPoints.getEntry(nfm - n, nfxm));
                     bMatrix.setEntry(nfm - n, nfxm,
                                   -bMatrix.getEntry(0, nfxm) - bMatrix.getEntry(nfm, nfxm));
-                    zMatrix.setEntry(0, nfxm, AccurateMath.sqrt(TWO) / (stepa * stepb));
-                    zMatrix.setEntry(nfm, nfxm, AccurateMath.sqrt(HALF) / rhosq);
-                    // zMatrix.setEntry(nfm, nfxm, AccurateMath.sqrt(HALF) * recip); // XXX "testAckley" and "testDiffPow" fail.
+                    zMatrix.setEntry(0, nfxm, JdkMath.sqrt(TWO) / (stepa * stepb));
+                    zMatrix.setEntry(nfm, nfxm, JdkMath.sqrt(HALF) / rhosq);
+                    // zMatrix.setEntry(nfm, nfxm, JdkMath.sqrt(HALF) * recip); // XXX "testAckley" and "testDiffPow" fail.
                     zMatrix.setEntry(nfm - n, nfxm,
                                   -zMatrix.getEntry(0, nfxm) - zMatrix.getEntry(nfm, nfxm));
                 }
@@ -1937,7 +1937,7 @@
             if (resid <= ZERO) {
                 state = 90; break;
             }
-            temp = AccurateMath.sqrt(stepsq * resid + ds * ds);
+            temp = JdkMath.sqrt(stepsq * resid + ds * ds);
             if (ds < ZERO) {
                 blen = (temp - ds) / stepsq;
             } else {
@@ -1946,7 +1946,7 @@
             stplen = blen;
             if (shs > ZERO) {
                 // Computing MIN
-                stplen = AccurateMath.min(blen, gredsq / shs);
+                stplen = JdkMath.min(blen, gredsq / shs);
             }
 
             // Reduce STPLEN if necessary in order to preserve the simple bounds,
@@ -1975,7 +1975,7 @@
                 ++iterc;
                 temp = shs / stepsq;
                 if (iact == -1 && temp > ZERO) {
-                    crvmin = AccurateMath.min(crvmin,temp);
+                    crvmin = JdkMath.min(crvmin,temp);
                     if (crvmin == MINUS_ONE) {
                         crvmin = temp;
                     }
@@ -1993,7 +1993,7 @@
                 }
                 // Computing MAX
                 final double d1 = stplen * (ggsav - HALF * stplen * shs);
-                sdec = AccurateMath.max(d1, ZERO);
+                sdec = JdkMath.max(d1, ZERO);
                 qred += sdec;
             }
 
@@ -2071,7 +2071,7 @@
             if (temp <= qred * 1e-4 * qred) {
                 state = 190; break;
             }
-            temp = AccurateMath.sqrt(temp);
+            temp = JdkMath.sqrt(temp);
             for (int i = 0; i < n; i++) {
                 if (xbdi.getEntry(i) == ZERO) {
                     s.setEntry(i, (dredg * trialStepPoint.getEntry(i) - dredsq * gnew.getEntry(i)) / temp);
@@ -2110,7 +2110,7 @@
                     d1 = trustRegionCenterOffset.getEntry(i) - lowerDifference.getEntry(i);
                     temp = ssq - d1 * d1;
                     if (temp > ZERO) {
-                        temp = AccurateMath.sqrt(temp) - s.getEntry(i);
+                        temp = JdkMath.sqrt(temp) - s.getEntry(i);
                         if (angbd * temp > tempa) {
                             angbd = tempa / temp;
                             iact = i;
@@ -2121,7 +2121,7 @@
                     d1 = upperDifference.getEntry(i) - trustRegionCenterOffset.getEntry(i);
                     temp = ssq - d1 * d1;
                     if (temp > ZERO) {
-                        temp = AccurateMath.sqrt(temp) + s.getEntry(i);
+                        temp = JdkMath.sqrt(temp) + s.getEntry(i);
                         if (angbd * temp > tempb) {
                             angbd = tempb / temp;
                             iact = i;
@@ -2226,9 +2226,9 @@
             for (int i = 0; i < n; i++) {
                 // Computing MAX
                 // Computing MIN
-                final double min = AccurateMath.min(trustRegionCenterOffset.getEntry(i) + trialStepPoint.getEntry(i),
+                final double min = JdkMath.min(trustRegionCenterOffset.getEntry(i) + trialStepPoint.getEntry(i),
                                             upperDifference.getEntry(i));
-                newPoint.setEntry(i, AccurateMath.max(min, lowerDifference.getEntry(i)));
+                newPoint.setEntry(i, JdkMath.max(min, lowerDifference.getEntry(i)));
                 if (xbdi.getEntry(i) == MINUS_ONE) {
                     newPoint.setEntry(i, lowerDifference.getEntry(i));
                 }
@@ -2317,7 +2317,7 @@
         for (int k = 0; k < npt; k++) {
             for (int j = 0; j < nptm; j++) {
                 // Computing MAX
-                ztest = AccurateMath.max(ztest, AccurateMath.abs(zMatrix.getEntry(k, j)));
+                ztest = JdkMath.max(ztest, JdkMath.abs(zMatrix.getEntry(k, j)));
             }
         }
         ztest *= 1e-20;
@@ -2326,12 +2326,12 @@
 
         for (int j = 1; j < nptm; j++) {
             final double d1 = zMatrix.getEntry(knew, j);
-            if (AccurateMath.abs(d1) > ztest) {
+            if (JdkMath.abs(d1) > ztest) {
                 // Computing 2nd power
                 final double d2 = zMatrix.getEntry(knew, 0);
                 // Computing 2nd power
                 final double d3 = zMatrix.getEntry(knew, j);
-                final double d4 = AccurateMath.sqrt(d2 * d2 + d3 * d3);
+                final double d4 = JdkMath.sqrt(d2 * d2 + d3 * d3);
                 final double d5 = zMatrix.getEntry(knew, 0) / d4;
                 final double d6 = zMatrix.getEntry(knew, j) / d4;
                 for (int i = 0; i < npt; i++) {
@@ -2355,7 +2355,7 @@
 
         // Complete the updating of ZMAT.
 
-        final double sqrtDenom = AccurateMath.sqrt(denom);
+        final double sqrtDenom = JdkMath.sqrt(denom);
         final double d1 = tau / sqrtDenom;
         final double d2 = zMatrix.getEntry(knew, 0) / sqrtDenom;
         for (int i = 0; i < npt; i++) {
@@ -2414,7 +2414,7 @@
         double minDiff = Double.POSITIVE_INFINITY;
         for (int i = 0; i < dimension; i++) {
             boundDifference[i] = upperBound[i] - lowerBound[i];
-            minDiff = AccurateMath.min(minDiff, boundDifference[i]);
+            minDiff = JdkMath.min(minDiff, boundDifference[i]);
         }
         if (minDiff < requiredMinDiff) {
             initialTrustRegionRadius = minDiff / 3.0;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/CMAESOptimizer.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/CMAESOptimizer.java
index eb92f7b..d657330 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/CMAESOptimizer.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/CMAESOptimizer.java
@@ -39,7 +39,7 @@
 import org.apache.commons.rng.UniformRandomProvider;
 import org.apache.commons.statistics.distribution.ContinuousDistribution;
 import org.apache.commons.statistics.distribution.NormalDistribution;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * An implementation of the active Covariance Matrix Adaptation Evolution Strategy (CMA-ES)
@@ -412,7 +412,7 @@
                 updateCovarianceDiagonalOnly(hsig, bestArz);
             }
             // Adapt step size sigma - Eq. (5)
-            sigma *= AccurateMath.exp(AccurateMath.min(1, (normps/chiN - 1) * cs / damps));
+            sigma *= JdkMath.exp(JdkMath.min(1, (normps/chiN - 1) * cs / damps));
             final double bestFitness = fitness[arindex[0]];
             final double worstFitness = fitness[arindex[arindex.length - 1]];
             if (bestValue > bestFitness) {
@@ -433,7 +433,7 @@
             final double[] sqrtDiagC = sqrt(diagC).getColumn(0);
             final double[] pcCol = pc.getColumn(0);
             for (int i = 0; i < dimension; i++) {
-                if (sigma * AccurateMath.max(AccurateMath.abs(pcCol[i]), sqrtDiagC[i]) > stopTolX) {
+                if (sigma * JdkMath.max(JdkMath.abs(pcCol[i]), sqrtDiagC[i]) > stopTolX) {
                     break;
                 }
                 if (i >= dimension - 1) {
@@ -448,8 +448,8 @@
             final double historyBest = min(fitnessHistory);
             final double historyWorst = max(fitnessHistory);
             if (iterations > 2 &&
-                AccurateMath.max(historyWorst, worstFitness) -
-                AccurateMath.min(historyBest, bestFitness) < stopTolFun) {
+                JdkMath.max(historyWorst, worstFitness) -
+                JdkMath.min(historyBest, bestFitness) < stopTolFun) {
                 break generationLoop;
             }
             if (iterations > fitnessHistory.length &&
@@ -473,11 +473,11 @@
             }
             // Adjust step size in case of equal function values (flat fitness)
             if (bestValue == fitness[arindex[(int)(0.1+lambda/4.)]]) {
-                sigma *= AccurateMath.exp(0.2 + cs / damps);
+                sigma *= JdkMath.exp(0.2 + cs / damps);
             }
-            if (iterations > 2 && AccurateMath.max(historyWorst, bestFitness) -
-                AccurateMath.min(historyBest, bestFitness) == 0) {
-                sigma *= AccurateMath.exp(0.2 + cs / damps);
+            if (iterations > 2 && JdkMath.max(historyWorst, bestFitness) -
+                JdkMath.min(historyBest, bestFitness) == 0) {
+                sigma *= JdkMath.exp(0.2 + cs / damps);
             }
             // store best in history
             push(fitnessHistory,bestFitness);
@@ -569,7 +569,7 @@
 
         // initialize selection strategy parameters
         mu = lambda / 2; // number of parents/points for recombination
-        logMu2 = AccurateMath.log(mu + 0.5);
+        logMu2 = JdkMath.log(mu + 0.5);
         weights = log(sequence(1, mu, 1)).scalarMultiply(-1).scalarAdd(logMu2);
         double sumw = 0;
         double sumwq = 0;
@@ -585,16 +585,16 @@
         cc = (4 + mueff / dimension) /
                 (dimension + 4 + 2 * mueff / dimension);
         cs = (mueff + 2) / (dimension + mueff + 3.);
-        damps = (1 + 2 * AccurateMath.max(0, AccurateMath.sqrt((mueff - 1) /
+        damps = (1 + 2 * JdkMath.max(0, JdkMath.sqrt((mueff - 1) /
                                                        (dimension + 1)) - 1)) *
-            AccurateMath.max(0.3,
+            JdkMath.max(0.3,
                          1 - dimension / (1e-6 + maxIterations)) + cs; // minor increment
         ccov1 = 2 / ((dimension + 1.3) * (dimension + 1.3) + mueff);
-        ccovmu = AccurateMath.min(1 - ccov1, 2 * (mueff - 2 + 1 / mueff) /
+        ccovmu = JdkMath.min(1 - ccov1, 2 * (mueff - 2 + 1 / mueff) /
                               ((dimension + 2) * (dimension + 2) + mueff));
-        ccov1Sep = AccurateMath.min(1, ccov1 * (dimension + 1.5) / 3);
-        ccovmuSep = AccurateMath.min(1 - ccov1, ccovmu * (dimension + 1.5) / 3);
-        chiN = AccurateMath.sqrt(dimension) *
+        ccov1Sep = JdkMath.min(1, ccov1 * (dimension + 1.5) / 3);
+        ccovmuSep = JdkMath.min(1 - ccov1, ccovmu * (dimension + 1.5) / 3);
+        chiN = JdkMath.sqrt(dimension) *
                 (1 - 1 / ((double) 4 * dimension) + 1 / ((double) 21 * dimension * dimension));
         // initialize CMA internal values - updated each generation
         xmean = MatrixUtils.createColumnRealMatrix(guess); // objective variables
@@ -626,14 +626,14 @@
     private boolean updateEvolutionPaths(RealMatrix zmean, RealMatrix xold) {
         ps = ps.scalarMultiply(1 - cs).add(
                 B.multiply(zmean).scalarMultiply(
-                        AccurateMath.sqrt(cs * (2 - cs) * mueff)));
+                        JdkMath.sqrt(cs * (2 - cs) * mueff)));
         normps = ps.getFrobeniusNorm();
         final boolean hsig = normps /
-            AccurateMath.sqrt(1 - AccurateMath.pow(1 - cs, 2 * iterations)) /
+            JdkMath.sqrt(1 - JdkMath.pow(1 - cs, 2 * iterations)) /
             chiN < 1.4 + 2 / ((double) dimension + 1);
         pc = pc.scalarMultiply(1 - cc);
         if (hsig) {
-            pc = pc.add(xmean.subtract(xold).scalarMultiply(AccurateMath.sqrt(cc * (2 - cc) * mueff) / sigma));
+            pc = pc.add(xmean.subtract(xold).scalarMultiply(JdkMath.sqrt(cc * (2 - cc) * mueff) / sigma));
         }
         return hsig;
     }
@@ -691,7 +691,7 @@
             if (isActiveCMA) {
                 // Adapt covariance matrix C active CMA
                 negccov = (1 - ccovmu) * 0.25 * mueff /
-                    (AccurateMath.pow(dimension + 2.0, 1.5) + 2 * mueff);
+                    (JdkMath.pow(dimension + 2.0, 1.5) + 2 * mueff);
                 // keep at least 0.66 in all directions, small popsize are most
                 // critical
                 final double negminresidualvariance = 0.66;
@@ -975,7 +975,7 @@
         private double penalty(final double[] x, final double[] repaired) {
             double penalty = 0;
             for (int i = 0; i < x.length; i++) {
-                double diff = AccurateMath.abs(x[i] - repaired[i]);
+                double diff = JdkMath.abs(x[i] - repaired[i]);
                 penalty += diff;
             }
             return isMinimize ? penalty : -penalty;
@@ -992,7 +992,7 @@
         final double[][] d = new double[m.getRowDimension()][m.getColumnDimension()];
         for (int r = 0; r < m.getRowDimension(); r++) {
             for (int c = 0; c < m.getColumnDimension(); c++) {
-                d[r][c] = AccurateMath.log(m.getEntry(r, c));
+                d[r][c] = JdkMath.log(m.getEntry(r, c));
             }
         }
         return new Array2DRowRealMatrix(d, false);
@@ -1006,7 +1006,7 @@
         final double[][] d = new double[m.getRowDimension()][m.getColumnDimension()];
         for (int r = 0; r < m.getRowDimension(); r++) {
             for (int c = 0; c < m.getColumnDimension(); c++) {
-                d[r][c] = AccurateMath.sqrt(m.getEntry(r, c));
+                d[r][c] = JdkMath.sqrt(m.getEntry(r, c));
             }
         }
         return new Array2DRowRealMatrix(d, false);
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/PowellOptimizer.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/PowellOptimizer.java
index 5c185a6..b09032f 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/PowellOptimizer.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/PowellOptimizer.java
@@ -27,7 +27,7 @@
 import org.apache.commons.math4.legacy.optim.nonlinear.scalar.LineSearch;
 import org.apache.commons.math4.legacy.optim.nonlinear.scalar.MultivariateOptimizer;
 import org.apache.commons.math4.legacy.optim.univariate.UnivariatePointValuePair;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Powell's algorithm.
@@ -59,7 +59,7 @@
     /**
      * Minimum relative tolerance.
      */
-    private static final double MIN_RELATIVE_TOLERANCE = 2 * AccurateMath.ulp(1d);
+    private static final double MIN_RELATIVE_TOLERANCE = 2 * JdkMath.ulp(1d);
     /**
      * Relative threshold.
      */
@@ -90,7 +90,7 @@
     public PowellOptimizer(double rel,
                            double abs,
                            ConvergenceChecker<PointValuePair> checker) {
-        this(rel, abs, AccurateMath.sqrt(rel), AccurateMath.sqrt(abs), checker);
+        this(rel, abs, JdkMath.sqrt(rel), JdkMath.sqrt(abs), checker);
     }
 
     /**
@@ -210,7 +210,7 @@
 
             // Default convergence check.
             boolean stop = 2 * (fX - fVal) <=
-                (relativeThreshold * (AccurateMath.abs(fX) + AccurateMath.abs(fVal)) +
+                (relativeThreshold * (JdkMath.abs(fX) + JdkMath.abs(fVal)) +
                  absoluteThreshold);
 
             final PointValuePair previous = new PointValuePair(x1, fX);
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/univariate/BracketFinder.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/univariate/BracketFinder.java
index 7dd4c2e..a0ecd50 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/univariate/BracketFinder.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/univariate/BracketFinder.java
@@ -21,7 +21,7 @@
 import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
 import org.apache.commons.math4.legacy.exception.TooManyEvaluationsException;
 import org.apache.commons.math4.legacy.optim.nonlinear.scalar.GoalType;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.IntegerSequence.Incrementor;
 
 /**
@@ -143,7 +143,7 @@
             double tmp2 = (xB - xC) * (fB - fA);
 
             double val = tmp2 - tmp1;
-            double denom = AccurateMath.abs(val) < EPS_MIN ? 2 * EPS_MIN : 2 * val;
+            double denom = JdkMath.abs(val) < EPS_MIN ? 2 * EPS_MIN : 2 * val;
 
             double w = xB - ((xB - xC) * tmp2 - (xB - xA) * tmp1) / denom;
             double wLim = xB + growLimit * (xC - xB);
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/univariate/BrentOptimizer.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/univariate/BrentOptimizer.java
index 8bfdf9b..7ed3e5e 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/univariate/BrentOptimizer.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/univariate/BrentOptimizer.java
@@ -20,7 +20,7 @@
 import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
 import org.apache.commons.math4.legacy.optim.ConvergenceChecker;
 import org.apache.commons.math4.legacy.optim.nonlinear.scalar.GoalType;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.numbers.core.Precision;
 
 /**
@@ -44,11 +44,11 @@
     /**
      * Golden section.
      */
-    private static final double GOLDEN_SECTION = 0.5 * (3 - AccurateMath.sqrt(5));
+    private static final double GOLDEN_SECTION = 0.5 * (3 - JdkMath.sqrt(5));
     /**
      * Minimum relative tolerance.
      */
-    private static final double MIN_RELATIVE_TOLERANCE = 2 * AccurateMath.ulp(1d);
+    private static final double MIN_RELATIVE_TOLERANCE = 2 * JdkMath.ulp(1d);
     /**
      * Relative threshold.
      */
@@ -151,18 +151,18 @@
 
         while (true) {
             final double m = 0.5 * (a + b);
-            final double tol1 = relativeThreshold * AccurateMath.abs(x) + absoluteThreshold;
+            final double tol1 = relativeThreshold * JdkMath.abs(x) + absoluteThreshold;
             final double tol2 = 2 * tol1;
 
             // Default stopping criterion.
-            final boolean stop = AccurateMath.abs(x - m) <= tol2 - 0.5 * (b - a);
+            final boolean stop = JdkMath.abs(x - m) <= tol2 - 0.5 * (b - a);
             if (!stop) {
                 double p = 0;
                 double q = 0;
                 double r = 0;
                 double u = 0;
 
-                if (AccurateMath.abs(e) > tol1) { // Fit parabola.
+                if (JdkMath.abs(e) > tol1) { // Fit parabola.
                     r = (x - w) * (fx - fv);
                     q = (x - v) * (fx - fw);
                     p = (x - v) * q - (x - w) * r;
@@ -179,7 +179,7 @@
 
                     if (p > q * (a - x) &&
                         p < q * (b - x) &&
-                        AccurateMath.abs(p) < AccurateMath.abs(0.5 * q * r)) {
+                        JdkMath.abs(p) < JdkMath.abs(0.5 * q * r)) {
                         // Parabolic interpolation step.
                         d = p / q;
                         u = x + d;
@@ -212,7 +212,7 @@
                 }
 
                 // Update by at least "tol1".
-                if (AccurateMath.abs(d) < tol1) {
+                if (JdkMath.abs(d) < tol1) {
                     if (d >= 0) {
                         u = x + tol1;
                     } else {
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/univariate/SimpleUnivariateValueChecker.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/univariate/SimpleUnivariateValueChecker.java
index b23b172..6dd7c48 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/univariate/SimpleUnivariateValueChecker.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/optim/univariate/SimpleUnivariateValueChecker.java
@@ -18,7 +18,7 @@
 
 import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
 import org.apache.commons.math4.legacy.optim.AbstractConvergenceChecker;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Simple implementation of the
@@ -119,8 +119,8 @@
 
         final double p = previous.getValue();
         final double c = current.getValue();
-        final double difference = AccurateMath.abs(p - c);
-        final double size = AccurateMath.max(AccurateMath.abs(p), AccurateMath.abs(c));
+        final double difference = JdkMath.abs(p - c);
+        final double size = JdkMath.max(JdkMath.abs(p), JdkMath.abs(c));
         return difference <= size * getRelativeThreshold() ||
             difference <= getAbsoluteThreshold();
     }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/random/CorrelatedVectorFactory.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/random/CorrelatedVectorFactory.java
index 2fc3a60..9b681d7 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/random/CorrelatedVectorFactory.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/random/CorrelatedVectorFactory.java
@@ -24,7 +24,7 @@
 import org.apache.commons.rng.sampling.distribution.ContinuousUniformSampler;
 import org.apache.commons.rng.sampling.distribution.ZigguratNormalizedGaussianSampler;
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.linear.RealMatrix;
 import org.apache.commons.math4.legacy.linear.RectangularCholeskyDecomposition;
 
@@ -62,7 +62,7 @@
  */
 public class CorrelatedVectorFactory {
     /** Square root of three. */
-    private static final double SQRT3 = AccurateMath.sqrt(3);
+    private static final double SQRT3 = JdkMath.sqrt(3);
     /** Mean vector. */
     private final double[] mean;
     /** Root of the covariance matrix. */
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/random/SobolSequenceGenerator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/random/SobolSequenceGenerator.java
index 8269eec..cf64e8b 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/random/SobolSequenceGenerator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/random/SobolSequenceGenerator.java
@@ -30,7 +30,7 @@
 import org.apache.commons.math4.legacy.exception.MathParseException;
 import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Implementation of a Sobol sequence.
@@ -58,7 +58,7 @@
     private static final int BITS = 52;
 
     /** The scaling factor. */
-    private static final double SCALE = AccurateMath.pow(2, BITS);
+    private static final double SCALE = JdkMath.pow(2, BITS);
 
     /** The maximum supported space dimension. */
     private static final int MAX_DIMENSION = 21201;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/special/BesselJ.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/special/BesselJ.java
index 1356986..f0941f6 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/special/BesselJ.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/special/BesselJ.java
@@ -23,7 +23,7 @@
 import org.apache.commons.math4.legacy.exception.ConvergenceException;
 import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * This class provides computation methods related to Bessel
@@ -165,7 +165,7 @@
             return res.vals[n];
         } else if (res.nVals < 0) {
             throw new MathIllegalArgumentException(LocalizedFormats.BESSEL_FUNCTION_BAD_ARGUMENT,order, x);
-        } else if (AccurateMath.abs(res.vals[res.nVals - 1]) < 1e-100) {
+        } else if (JdkMath.abs(res.vals[res.nVals - 1]) < 1e-100) {
             return res.vals[n]; // underflow; return value (will be zero)
         }
         throw new ConvergenceException(LocalizedFormats.BESSEL_FUNCTION_FAILED_CONVERGENCE, order, x);
@@ -283,7 +283,7 @@
                     halfx = 0.5 * x;
                 }
                 if (alpha != 0) {
-                    tempa = AccurateMath.pow(halfx, alpha) /
+                    tempa = JdkMath.pow(halfx, alpha) /
                             (alpha * Gamma.value(alpha));
                 }
                 tempb = 0;
@@ -323,7 +323,7 @@
                 // ---------------------------------------------------------------------
                 // Asymptotic series for X > 25
                 // ---------------------------------------------------------------------
-                final double xc = AccurateMath.sqrt(PI2 / x);
+                final double xc = JdkMath.sqrt(PI2 / x);
                 final double mul = 0.125 / x;
                 final double xin = mul * mul;
                 int m = 0;
@@ -341,8 +341,8 @@
                 // ---------------------------------------------------------------------
                 double t = (double) ((int) ((x / TWOPI) + 0.5));
                 final double z = x - t * TOWPI1 - t * TWOPI2 - (alpha + 0.5) / PI2;
-                double vsin = AccurateMath.sin(z);
-                double vcos = AccurateMath.cos(z);
+                double vsin = JdkMath.sin(z);
+                double vcos = JdkMath.cos(z);
                 double gnu = 2 * alpha;
                 double capq;
                 double capp;
@@ -457,7 +457,7 @@
                             p = plast * tover;
                             n -= 1;
                             en -= 2.0;
-                            nend = AccurateMath.min(nb, n);
+                            nend = JdkMath.min(nb, n);
                             for (int l = nstart; l <= nend; l++) {
                                 pold = psavel;
                                 psavel = psave;
@@ -479,8 +479,8 @@
                         // ---------------------------------------------------------------------
                         // Calculate special significance test for NBMX > 2.
                         // ---------------------------------------------------------------------
-                        test = AccurateMath.max(test, AccurateMath.sqrt(plast * ENSIG) *
-                                                  AccurateMath.sqrt(2 * p));
+                        test = JdkMath.max(test, JdkMath.sqrt(plast * ENSIG) *
+                                                  JdkMath.sqrt(2 * p));
                     }
                 }
                 // ---------------------------------------------------------------------
@@ -620,8 +620,8 @@
                 // Normalize. Divide all B(N) by sum.
                 // ---------------------------------------------------------------------
 
-                if (AccurateMath.abs(alpha) > 1e-16) {
-                    sum *= Gamma.value(alpha) * AccurateMath.pow(x * 0.5, -alpha);
+                if (JdkMath.abs(alpha) > 1e-16) {
+                    sum *= Gamma.value(alpha) * JdkMath.pow(x * 0.5, -alpha);
                 }
                 tempa = ENMTEN;
                 if (sum > 1) {
@@ -629,7 +629,7 @@
                 }
 
                 for (n = 0; n < nb; n++) {
-                    if (AccurateMath.abs(b[n]) < tempa) {
+                    if (JdkMath.abs(b[n]) < tempa) {
                         b[n] = 0;
                     }
                     b[n] /= sum;
@@ -642,7 +642,7 @@
             if (b.length > 0) {
                 b[0] = 0;
             }
-            ncalc = AccurateMath.min(nb, 0) - 1;
+            ncalc = JdkMath.min(nb, 0) - 1;
         }
         return new BesselJResult(Arrays.copyOf(b, b.length), ncalc);
     }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/correlation/KendallsCorrelation.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/correlation/KendallsCorrelation.java
index 24bc4ef..3f212d6 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/correlation/KendallsCorrelation.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/correlation/KendallsCorrelation.java
@@ -23,7 +23,7 @@
 import org.apache.commons.math4.legacy.linear.BlockRealMatrix;
 import org.apache.commons.math4.legacy.linear.MatrixUtils;
 import org.apache.commons.math4.legacy.linear.RealMatrix;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.Pair;
 
 /**
@@ -208,9 +208,9 @@
         for (int segmentSize = 1; segmentSize < n; segmentSize <<= 1) {
             for (int offset = 0; offset < n; offset += 2 * segmentSize) {
                 int i = offset;
-                final int iEnd = AccurateMath.min(i + segmentSize, n);
+                final int iEnd = JdkMath.min(i + segmentSize, n);
                 int j = iEnd;
-                final int jEnd = AccurateMath.min(j + segmentSize, n);
+                final int jEnd = JdkMath.min(j + segmentSize, n);
 
                 int copyLocation = offset;
                 while (i < iEnd || j < jEnd) {
@@ -257,7 +257,7 @@
 
         final long concordantMinusDiscordant = numPairs - tiedXPairs - tiedYPairs + tiedXYPairs - 2 * swaps;
         final double nonTiedPairsMultiplied = (numPairs - tiedXPairs) * (double) (numPairs - tiedYPairs);
-        return concordantMinusDiscordant / AccurateMath.sqrt(nonTiedPairsMultiplied);
+        return concordantMinusDiscordant / JdkMath.sqrt(nonTiedPairsMultiplied);
     }
 
     /**
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/correlation/PearsonsCorrelation.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/correlation/PearsonsCorrelation.java
index eda73a6..3790e04 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/correlation/PearsonsCorrelation.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/correlation/PearsonsCorrelation.java
@@ -24,7 +24,7 @@
 import org.apache.commons.math4.legacy.linear.BlockRealMatrix;
 import org.apache.commons.math4.legacy.linear.RealMatrix;
 import org.apache.commons.math4.legacy.stat.regression.SimpleRegression;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Computes Pearson's product-moment correlation coefficients for pairs of arrays
@@ -165,7 +165,7 @@
         for (int i = 0; i < nVars; i++) {
             for (int j = 0; j < nVars; j++) {
                 double r = correlationMatrix.getEntry(i, j);
-                out[i][j] = AccurateMath.sqrt((1 - r * r) /(nObs - 2));
+                out[i][j] = JdkMath.sqrt((1 - r * r) /(nObs - 2));
             }
         }
         return new BlockRealMatrix(out);
@@ -201,7 +201,7 @@
                     out[i][j] = 0d;
                 } else {
                     double r = correlationMatrix.getEntry(i, j);
-                    double t = AccurateMath.abs(r * AccurateMath.sqrt((nObs - 2)/(1 - r * r)));
+                    double t = JdkMath.abs(r * JdkMath.sqrt((nObs - 2)/(1 - r * r)));
                     out[i][j] = 2 * tDistribution.cumulativeProbability(-t);
                 }
             }
@@ -300,11 +300,11 @@
         int nVars = covarianceMatrix.getColumnDimension();
         RealMatrix outMatrix = new BlockRealMatrix(nVars, nVars);
         for (int i = 0; i < nVars; i++) {
-            double sigma = AccurateMath.sqrt(covarianceMatrix.getEntry(i, i));
+            double sigma = JdkMath.sqrt(covarianceMatrix.getEntry(i, i));
             outMatrix.setEntry(i, i, 1d);
             for (int j = 0; j < i; j++) {
                 double entry = covarianceMatrix.getEntry(i, j) /
-                       (sigma * AccurateMath.sqrt(covarianceMatrix.getEntry(j, j)));
+                       (sigma * JdkMath.sqrt(covarianceMatrix.getEntry(j, j)));
                 outMatrix.setEntry(i, j, entry);
                 outMatrix.setEntry(j, i, entry);
             }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/DescriptiveStatistics.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/DescriptiveStatistics.java
index ae7def1..b418c3e 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/DescriptiveStatistics.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/DescriptiveStatistics.java
@@ -34,7 +34,7 @@
 import org.apache.commons.math4.legacy.stat.descriptive.rank.Percentile;
 import org.apache.commons.math4.legacy.stat.descriptive.summary.Sum;
 import org.apache.commons.math4.legacy.stat.descriptive.summary.SumOfSquares;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 
 /**
@@ -272,7 +272,7 @@
         double stdDev = Double.NaN;
         if (getN() > 0) {
             if (getN() > 1) {
-                stdDev = AccurateMath.sqrt(getVariance());
+                stdDev = JdkMath.sqrt(getVariance());
             } else {
                 stdDev = 0.0;
             }
@@ -289,7 +289,7 @@
      */
     public double getQuadraticMean() {
         final long n = getN();
-        return n > 0 ? AccurateMath.sqrt(getSumsq() / n) : Double.NaN;
+        return n > 0 ? JdkMath.sqrt(getSumsq() / n) : Double.NaN;
     }
 
     /**
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/MultivariateSummaryStatistics.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/MultivariateSummaryStatistics.java
index 128bf9b..10a4883 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/MultivariateSummaryStatistics.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/MultivariateSummaryStatistics.java
@@ -31,7 +31,7 @@
 import org.apache.commons.math4.legacy.stat.descriptive.summary.Sum;
 import org.apache.commons.math4.legacy.stat.descriptive.summary.SumOfLogs;
 import org.apache.commons.math4.legacy.stat.descriptive.summary.SumOfSquares;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 import org.apache.commons.numbers.core.Precision;
 
@@ -255,7 +255,7 @@
         } else {
             RealMatrix matrix = covarianceImpl.getResult();
             for (int i = 0; i < k; ++i) {
-                stdDev[i] = AccurateMath.sqrt(matrix.getEntry(i, i));
+                stdDev[i] = JdkMath.sqrt(matrix.getEntry(i, i));
             }
         }
         return stdDev;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/ResizableDoubleArray.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/ResizableDoubleArray.java
index de33db3..5f5c2a9 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/ResizableDoubleArray.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/ResizableDoubleArray.java
@@ -25,7 +25,7 @@
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 
 /**
@@ -540,16 +540,16 @@
      * after expansion will be {@code internalArray.length + expansionFactor}.
      */
     protected void expand() {
-        // notice the use of AccurateMath.ceil(), this guarantees that we will always
+        // notice the use of JdkMath.ceil(), this guarantees that we will always
         // have an array of at least currentSize + 1.   Assume that the
         // current initial capacity is 1 and the expansion factor
         // is 1.000000000000000001.  The newly calculated size will be
         // rounded up to 2 after the multiplication is performed.
         int newSize = 0;
         if (expansionMode == ExpansionMode.MULTIPLICATIVE) {
-            newSize = (int) AccurateMath.ceil(internalArray.length * expansionFactor);
+            newSize = (int) JdkMath.ceil(internalArray.length * expansionFactor);
         } else {
-            newSize = (int) (internalArray.length + AccurateMath.round(expansionFactor));
+            newSize = (int) (internalArray.length + JdkMath.round(expansionFactor));
         }
         final double[] tempArray = new double[newSize];
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/StatisticalSummaryValues.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/StatisticalSummaryValues.java
index 23fae65..6e454d1 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/StatisticalSummaryValues.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/StatisticalSummaryValues.java
@@ -18,7 +18,7 @@
 
 import java.io.Serializable;
 
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.numbers.core.Precision;
 
 /**
@@ -115,7 +115,7 @@
      */
     @Override
     public double getStandardDeviation() {
-        return AccurateMath.sqrt(variance);
+        return JdkMath.sqrt(variance);
     }
 
     /**
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/SummaryStatistics.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/SummaryStatistics.java
index c3b9c5d..c0935c6 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/SummaryStatistics.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/SummaryStatistics.java
@@ -30,7 +30,7 @@
 import org.apache.commons.math4.legacy.stat.descriptive.summary.Sum;
 import org.apache.commons.math4.legacy.stat.descriptive.summary.SumOfLogs;
 import org.apache.commons.math4.legacy.stat.descriptive.summary.SumOfSquares;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.numbers.core.Precision;
 
 /**
@@ -219,7 +219,7 @@
         double stdDev = Double.NaN;
         if (getN() > 0) {
             if (getN() > 1) {
-                stdDev = AccurateMath.sqrt(getVariance());
+                stdDev = JdkMath.sqrt(getVariance());
             } else {
                 stdDev = 0.0;
             }
@@ -236,7 +236,7 @@
      */
     public double getQuadraticMean() {
         final long size = getN();
-        return size > 0 ? AccurateMath.sqrt(getSumsq() / size) : Double.NaN;
+        return size > 0 ? JdkMath.sqrt(getSumsq() / size) : Double.NaN;
     }
 
     /**
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/GeometricMean.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/GeometricMean.java
index 09e683c..7c6d075 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/GeometricMean.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/GeometricMean.java
@@ -25,7 +25,7 @@
 import org.apache.commons.math4.legacy.stat.descriptive.AbstractStorelessUnivariateStatistic;
 import org.apache.commons.math4.legacy.stat.descriptive.StorelessUnivariateStatistic;
 import org.apache.commons.math4.legacy.stat.descriptive.summary.SumOfLogs;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Returns the <a href="http://www.xycoon.com/geometric_mean.htm">
@@ -108,7 +108,7 @@
     @Override
     public double getResult() {
         if (sumOfLogs.getN() > 0) {
-            return AccurateMath.exp(sumOfLogs.getResult() / sumOfLogs.getN());
+            return JdkMath.exp(sumOfLogs.getResult() / sumOfLogs.getN());
         } else {
             return Double.NaN;
         }
@@ -141,7 +141,7 @@
     @Override
     public double evaluate(final double[] values, final int begin, final int length)
         throws MathIllegalArgumentException {
-        return AccurateMath.exp(sumOfLogs.evaluate(values, begin, length) / length);
+        return JdkMath.exp(sumOfLogs.evaluate(values, begin, length) / length);
     }
 
     /**
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/Kurtosis.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/Kurtosis.java
index 367a223..a6f021d 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/Kurtosis.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/Kurtosis.java
@@ -21,7 +21,7 @@
 import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
 import org.apache.commons.math4.legacy.stat.descriptive.AbstractStorelessUnivariateStatistic;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 
 
@@ -171,15 +171,15 @@
             Variance variance = new Variance();
             variance.incrementAll(values, begin, length);
             double mean = variance.moment.m1;
-            double stdDev = AccurateMath.sqrt(variance.getResult());
+            double stdDev = JdkMath.sqrt(variance.getResult());
 
             // Sum the ^4 of the distance from the mean divided by the
             // standard deviation
             double accum3 = 0.0;
             for (int i = begin; i < begin + length; i++) {
-                accum3 += AccurateMath.pow(values[i] - mean, 4.0);
+                accum3 += JdkMath.pow(values[i] - mean, 4.0);
             }
-            accum3 /= AccurateMath.pow(stdDev, 4.0d);
+            accum3 /= JdkMath.pow(stdDev, 4.0d);
 
             // Get N
             double n0 = length;
@@ -187,7 +187,7 @@
             double coefficientOne =
                 (n0 * (n0 + 1)) / ((n0 - 1) * (n0 - 2) * (n0 - 3));
             double termTwo =
-                (3 * AccurateMath.pow(n0 - 1, 2.0)) / ((n0 - 2) * (n0 - 3));
+                (3 * JdkMath.pow(n0 - 1, 2.0)) / ((n0 - 2) * (n0 - 3));
 
             // Calculate kurtosis
             kurt = (coefficientOne * accum3) - termTwo;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/Skewness.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/Skewness.java
index 05eb189..9fd0579 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/Skewness.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/Skewness.java
@@ -21,7 +21,7 @@
 import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
 import org.apache.commons.math4.legacy.stat.descriptive.AbstractStorelessUnivariateStatistic;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 
 /**
@@ -123,7 +123,7 @@
         } else {
             double n0 = moment.getN();
             return  (n0 * moment.m3) /
-            ((n0 - 1) * (n0 -2) * AccurateMath.sqrt(variance) * variance);
+            ((n0 - 1) * (n0 -2) * JdkMath.sqrt(variance) * variance);
         }
     }
 
@@ -191,7 +191,7 @@
                     final double d = values[i] - m;
                     accum3 += d * d * d;
                 }
-                accum3 /= variance * AccurateMath.sqrt(variance);
+                accum3 /= variance * JdkMath.sqrt(variance);
 
                 // Get N
                 double n0 = length;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/StandardDeviation.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/StandardDeviation.java
index cd9483f..26ecef2 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/StandardDeviation.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/StandardDeviation.java
@@ -21,7 +21,7 @@
 import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
 import org.apache.commons.math4.legacy.stat.descriptive.AbstractStorelessUnivariateStatistic;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Computes the sample standard deviation.  The standard deviation
@@ -125,7 +125,7 @@
      */
     @Override
     public double getResult() {
-        return AccurateMath.sqrt(variance.getResult());
+        return JdkMath.sqrt(variance.getResult());
     }
 
     /**
@@ -152,7 +152,7 @@
      */
     @Override
     public double evaluate(final double[] values) throws MathIllegalArgumentException  {
-        return AccurateMath.sqrt(variance.evaluate(values));
+        return JdkMath.sqrt(variance.evaluate(values));
     }
 
     /**
@@ -176,7 +176,7 @@
     @Override
     public double evaluate(final double[] values, final int begin, final int length)
         throws MathIllegalArgumentException  {
-        return AccurateMath.sqrt(variance.evaluate(values, begin, length));
+        return JdkMath.sqrt(variance.evaluate(values, begin, length));
     }
 
     /**
@@ -205,7 +205,7 @@
      */
     public double evaluate(final double[] values, final double mean,
                            final int begin, final int length) throws MathIllegalArgumentException  {
-        return AccurateMath.sqrt(variance.evaluate(values, mean, begin, length));
+        return JdkMath.sqrt(variance.evaluate(values, mean, begin, length));
     }
 
     /**
@@ -231,7 +231,7 @@
      */
     public double evaluate(final double[] values, final double mean)
         throws MathIllegalArgumentException  {
-        return AccurateMath.sqrt(variance.evaluate(values, mean));
+        return JdkMath.sqrt(variance.evaluate(values, mean));
     }
 
     /**
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/KthSelector.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/KthSelector.java
index fd9d351..3211154 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/KthSelector.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/KthSelector.java
@@ -20,7 +20,7 @@
 import java.util.Arrays;
 
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * A Simple K<sup>th</sup> selector implementation to pick up the
@@ -101,11 +101,11 @@
             } else if (k < pivot) {
                 // the element is in the left partition
                 end  = pivot;
-                node = AccurateMath.min(2 * node + 1, usePivotsHeap ? pivotsHeap.length : end);
+                node = JdkMath.min(2 * node + 1, usePivotsHeap ? pivotsHeap.length : end);
             } else {
                 // the element is in the right partition
                 begin = pivot + 1;
-                node  = AccurateMath.min(2 * node + 2, usePivotsHeap ? pivotsHeap.length : end);
+                node  = JdkMath.min(2 * node + 2, usePivotsHeap ? pivotsHeap.length : end);
             }
         }
         Arrays.sort(work, begin, end);
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/Percentile.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/Percentile.java
index 8d2ac88..e6cc453 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/Percentile.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/Percentile.java
@@ -30,7 +30,7 @@
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
 import org.apache.commons.math4.legacy.stat.descriptive.AbstractUnivariateStatistic;
 import org.apache.commons.math4.legacy.stat.ranking.NaNStrategy;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 
 /**
@@ -965,7 +965,7 @@
             protected double estimate(final double[] values,
                                       final int[] pivotsHeap, final double pos,
                                       final int length, final KthSelector selector) {
-                return super.estimate(values, pivotsHeap, AccurateMath.ceil(pos - 0.5), length, selector);
+                return super.estimate(values, pivotsHeap, JdkMath.ceil(pos - 0.5), length, selector);
             }
             @Override
             public double evaluate(final double[] work, final double[] sampleWeights,
@@ -1002,9 +1002,9 @@
                                       final int[] pivotsHeap, final double pos,
                                       final int length, final KthSelector selector) {
                 final double low =
-                        super.estimate(values, pivotsHeap, AccurateMath.ceil(pos - 0.5), length, selector);
+                        super.estimate(values, pivotsHeap, JdkMath.ceil(pos - 0.5), length, selector);
                 final double high =
-                        super.estimate(values, pivotsHeap,AccurateMath.floor(pos + 0.5), length, selector);
+                        super.estimate(values, pivotsHeap,JdkMath.floor(pos + 0.5), length, selector);
                 return (low + high) / 2;
             }
             @Override
@@ -1026,7 +1026,7 @@
             protected double index(final double p, final int length) {
                 final double minLimit = 1d/2 / length;
                 return Double.compare(p, minLimit) <= 0 ?
-                        0 : AccurateMath.rint(length * p);
+                        0 : JdkMath.rint(length * p);
             }
             @Override
             public double evaluate(final double[] work, final double[] sampleWeights,
@@ -1272,7 +1272,7 @@
                                   final double pos, final int length,
                                   final KthSelector selector) {
 
-            final double fpos = AccurateMath.floor(pos);
+            final double fpos = JdkMath.floor(pos);
             final int intPos = (int) fpos;
             final double dif = pos - fpos;
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/summary/Product.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/summary/Product.java
index 54aae6d..5701016 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/summary/Product.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/summary/Product.java
@@ -22,7 +22,7 @@
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
 import org.apache.commons.math4.legacy.stat.descriptive.AbstractStorelessUnivariateStatistic;
 import org.apache.commons.math4.legacy.stat.descriptive.WeightedEvaluation;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 
 /**
@@ -165,7 +165,7 @@
         if (MathArrays.verifyValues(values, weights, begin, length, true)) {
             product = 1.0;
             for (int i = begin; i < begin + length; i++) {
-                product *= AccurateMath.pow(values[i], weights[i]);
+                product *= JdkMath.pow(values[i], weights[i]);
             }
         }
         return product;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/summary/SumOfLogs.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/summary/SumOfLogs.java
index 6d77f7c..fd0e571 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/summary/SumOfLogs.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/summary/SumOfLogs.java
@@ -21,13 +21,13 @@
 import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
 import org.apache.commons.math4.legacy.stat.descriptive.AbstractStorelessUnivariateStatistic;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 
 /**
  * Returns the sum of the natural logs for this collection of values.
  * <p>
- * Uses {@link org.apache.commons.math4.legacy.core.jdkmath.AccurateMath#log(double)} to compute the logs.
+ * Uses {@link org.apache.commons.math4.core.jdkmath.JdkMath#log(double)} to compute the logs.
  * Therefore,
  * <ul>
  * <li>If any of values are &lt; 0, the result is <code>NaN.</code></li>
@@ -81,7 +81,7 @@
      */
     @Override
     public void increment(final double d) {
-        value += AccurateMath.log(d);
+        value += JdkMath.log(d);
         n++;
     }
 
@@ -135,7 +135,7 @@
         if (MathArrays.verifyValues(values, begin, length, true)) {
             sumLog = 0.0;
             for (int i = begin; i < begin + length; i++) {
-                sumLog += AccurateMath.log(values[i]);
+                sumLog += JdkMath.log(values[i]);
             }
         }
         return sumLog;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/ChiSquareTest.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/ChiSquareTest.java
index e695d3f..2d93332 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/ChiSquareTest.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/ChiSquareTest.java
@@ -25,7 +25,7 @@
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
 import org.apache.commons.math4.legacy.exception.ZeroException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 
 /**
@@ -98,7 +98,7 @@
         }
         double ratio = 1.0d;
         boolean rescale = false;
-        if (AccurateMath.abs(sumExpected - sumObserved) > 10E-6) {
+        if (JdkMath.abs(sumExpected - sumObserved) > 10E-6) {
             ratio = sumObserved / sumExpected;
             rescale = true;
         }
@@ -464,7 +464,7 @@
         // Compare and compute weight only if different
         unequalCounts = countSum1 != countSum2;
         if (unequalCounts) {
-            weight = AccurateMath.sqrt((double) countSum1 / (double) countSum2);
+            weight = JdkMath.sqrt((double) countSum1 / (double) countSum2);
         }
         // Compute ChiSquare statistic
         double sumSq = 0.0d;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/GTest.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/GTest.java
index 6dddb4a..27dd913 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/GTest.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/GTest.java
@@ -24,7 +24,7 @@
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
 import org.apache.commons.math4.legacy.exception.ZeroException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 
 /**
@@ -94,15 +94,15 @@
         }
         double ratio = 1d;
         boolean rescale = false;
-        if (AccurateMath.abs(sumExpected - sumObserved) > 10E-6) {
+        if (JdkMath.abs(sumExpected - sumObserved) > 10E-6) {
             ratio = sumObserved / sumExpected;
             rescale = true;
         }
         double sum = 0d;
         for (int i = 0; i < observed.length; i++) {
             final double dev = rescale ?
-                    AccurateMath.log((double) observed[i] / (ratio * expected[i])) :
-                        AccurateMath.log((double) observed[i] / expected[i]);
+                    JdkMath.log((double) observed[i] / (ratio * expected[i])) :
+                        JdkMath.log((double) observed[i] / expected[i]);
             sum += ((double) observed[i]) * dev;
         }
         return 2d * sum;
@@ -269,7 +269,7 @@
             for (int j = 0; j < k[i].length; j++) {
                 if (k[i][j] != 0) {
                     final double pIJ = (double) k[i][j] / sumK;
-                    h += pIJ * AccurateMath.log(pIJ);
+                    h += pIJ * JdkMath.log(pIJ);
                 }
             }
         }
@@ -296,7 +296,7 @@
         for (int i = 0; i < k.length; i++) {
             if (k[i] != 0) {
                 final double pI = (double) k[i] / sumK;
-                h += pI * AccurateMath.log(pI);
+                h += pI * JdkMath.log(pI);
             }
         }
         return -h;
@@ -421,7 +421,7 @@
             final long k21, final long k22) {
         final double llr = gDataSetsComparison(
                 new long[]{k11, k12}, new long[]{k21, k22});
-        double sqrt = AccurateMath.sqrt(llr);
+        double sqrt = JdkMath.sqrt(llr);
         if ((double) k11 / (k11 + k12) < (double) k21 / (k21 + k22)) {
             sqrt = -sqrt;
         }
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/KolmogorovSmirnovTest.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/KolmogorovSmirnovTest.java
index b189a5f..b8a5432 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/KolmogorovSmirnovTest.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/KolmogorovSmirnovTest.java
@@ -39,7 +39,7 @@
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
 import org.apache.commons.math4.legacy.linear.MatrixUtils;
 import org.apache.commons.math4.legacy.linear.RealMatrix;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.core.MathArrays;
 import org.apache.commons.math4.legacy.field.linalg.FieldDenseMatrix;
 
@@ -112,7 +112,7 @@
  */
 public class KolmogorovSmirnovTest {
     /** pi^2. */
-    private static final double PI_SQUARED = AccurateMath.PI * AccurateMath.PI;
+    private static final double PI_SQUARED = JdkMath.PI * JdkMath.PI;
     /**
      * Bound on the number of partial sums in {@link #ksSum(double, double, int)}.
      */
@@ -171,7 +171,7 @@
         double d = 0d;
         for (int i = 1; i <= n; i++) {
             final double yi = distribution.cumulativeProbability(dataCopy[i - 1]);
-            final double currD = AccurateMath.max(yi - (i - 1) / nd, i / nd - yi);
+            final double currD = JdkMath.max(yi - (i - 1) / nd, i / nd - yi);
             if (currD > d) {
                 d = currD;
             }
@@ -542,7 +542,7 @@
      */
     public double pelzGood(double d, int n) {
         // Change the variable since approximation is for the distribution evaluated at d / sqrt(n)
-        final double sqrtN = AccurateMath.sqrt(n);
+        final double sqrtN = JdkMath.sqrt(n);
         final double z = d * sqrtN;
         final double z2 = d * d * n;
         final double z4 = z2 * z2;
@@ -560,7 +560,7 @@
         int k = 1;
         for (; k < MAXIMUM_PARTIAL_SUM_COUNT; k++) {
             kTerm = 2 * k - 1;
-            increment = AccurateMath.exp(-z2Term * kTerm * kTerm);
+            increment = JdkMath.exp(-z2Term * kTerm * kTerm);
             sum += increment;
             if (increment <= PG_SUM_RELATIVE_ERROR * sum) {
                 break;
@@ -569,7 +569,7 @@
         if (k == MAXIMUM_PARTIAL_SUM_COUNT) {
             throw new TooManyIterationsException(MAXIMUM_PARTIAL_SUM_COUNT);
         }
-        ret = sum * AccurateMath.sqrt(2 * AccurateMath.PI) / z;
+        ret = sum * JdkMath.sqrt(2 * JdkMath.PI) / z;
 
         // K_1(z)
         // Sum is -inf to inf, but k term is always (k + 1/2) ^ 2, so really have
@@ -581,16 +581,16 @@
         for (k = 0; k < MAXIMUM_PARTIAL_SUM_COUNT; k++) {
             kTerm = k + 0.5;
             kTerm2 = kTerm * kTerm;
-            increment = (PI_SQUARED * kTerm2 - z2) * AccurateMath.exp(-PI_SQUARED * kTerm2 / twoZ2);
+            increment = (PI_SQUARED * kTerm2 - z2) * JdkMath.exp(-PI_SQUARED * kTerm2 / twoZ2);
             sum += increment;
-            if (AccurateMath.abs(increment) < PG_SUM_RELATIVE_ERROR * AccurateMath.abs(sum)) {
+            if (JdkMath.abs(increment) < PG_SUM_RELATIVE_ERROR * JdkMath.abs(sum)) {
                 break;
             }
         }
         if (k == MAXIMUM_PARTIAL_SUM_COUNT) {
             throw new TooManyIterationsException(MAXIMUM_PARTIAL_SUM_COUNT);
         }
-        final double sqrtHalfPi = AccurateMath.sqrt(AccurateMath.PI / 2);
+        final double sqrtHalfPi = JdkMath.sqrt(JdkMath.PI / 2);
         // Instead of doubling sum, divide by 3 instead of 6
         ret += sum * sqrtHalfPi / (3 * z4 * sqrtN);
 
@@ -607,9 +607,9 @@
             kTerm = k + 0.5;
             kTerm2 = kTerm * kTerm;
             increment =  (z6Term + z4Term + PI_SQUARED * (z4Term - z2Term) * kTerm2 +
-                    pi4 * (1 - twoZ2) * kTerm2 * kTerm2) * AccurateMath.exp(-PI_SQUARED * kTerm2 / twoZ2);
+                    pi4 * (1 - twoZ2) * kTerm2 * kTerm2) * JdkMath.exp(-PI_SQUARED * kTerm2 / twoZ2);
             sum += increment;
-            if (AccurateMath.abs(increment) < PG_SUM_RELATIVE_ERROR * AccurateMath.abs(sum)) {
+            if (JdkMath.abs(increment) < PG_SUM_RELATIVE_ERROR * JdkMath.abs(sum)) {
                 break;
             }
         }
@@ -620,9 +620,9 @@
         kTerm2 = 0;
         for (k = 1; k < MAXIMUM_PARTIAL_SUM_COUNT; k++) {
             kTerm2 = (double) k * k;
-            increment = PI_SQUARED * kTerm2 * AccurateMath.exp(-PI_SQUARED * kTerm2 / twoZ2);
+            increment = PI_SQUARED * kTerm2 * JdkMath.exp(-PI_SQUARED * kTerm2 / twoZ2);
             sum2 += increment;
-            if (AccurateMath.abs(increment) < PG_SUM_RELATIVE_ERROR * AccurateMath.abs(sum2)) {
+            if (JdkMath.abs(increment) < PG_SUM_RELATIVE_ERROR * JdkMath.abs(sum2)) {
                 break;
             }
         }
@@ -645,9 +645,9 @@
             kTerm6 = kTerm4 * kTerm2;
             increment = (pi6 * kTerm6 * (5 - 30 * z2) + pi4 * kTerm4 * (-60 * z2 + 212 * z4) +
                             PI_SQUARED * kTerm2 * (135 * z4 - 96 * z6) - 30 * z6 - 90 * z8) *
-                    AccurateMath.exp(-PI_SQUARED * kTerm2 / twoZ2);
+                    JdkMath.exp(-PI_SQUARED * kTerm2 / twoZ2);
             sum += increment;
-            if (AccurateMath.abs(increment) < PG_SUM_RELATIVE_ERROR * AccurateMath.abs(sum)) {
+            if (JdkMath.abs(increment) < PG_SUM_RELATIVE_ERROR * JdkMath.abs(sum)) {
                 break;
             }
         }
@@ -659,9 +659,9 @@
             kTerm2 = (double) k * k;
             kTerm4 = kTerm2 * kTerm2;
             increment = (-pi4 * kTerm4 + 3 * PI_SQUARED * kTerm2 * z2) *
-                    AccurateMath.exp(-PI_SQUARED * kTerm2 / twoZ2);
+                    JdkMath.exp(-PI_SQUARED * kTerm2 / twoZ2);
             sum2 += increment;
-            if (AccurateMath.abs(increment) < PG_SUM_RELATIVE_ERROR * AccurateMath.abs(sum2)) {
+            if (JdkMath.abs(increment) < PG_SUM_RELATIVE_ERROR * JdkMath.abs(sum2)) {
                 break;
             }
         }
@@ -821,7 +821,7 @@
          * (2h - 1)^m )/m!" Since 0 <= h < 1, then if h > 1/2 is sufficient to check:
          */
         if (Double.compare(h, 0.5) > 0) {
-            hData[m - 1][0] += AccurateMath.pow(2 * h - 1, m);
+            hData[m - 1][0] += JdkMath.pow(2 * h - 1, m);
         }
 
         /*
@@ -887,7 +887,7 @@
         double partialSum = 0.5d;
         double delta = 1;
         while (delta > tolerance && i < maxIterations) {
-            delta = AccurateMath.exp(x * i * i);
+            delta = JdkMath.exp(x * i * i);
             partialSum += sign * delta;
             sign *= -1;
             i++;
@@ -914,8 +914,8 @@
     private static long calculateIntegralD(double d, int n, int m, boolean strict) {
         final double tol = 1e-12;  // d-values within tol of one another are considered equal
         long nm = n * (long)m;
-        long upperBound = (long)AccurateMath.ceil((d - tol) * nm);
-        long lowerBound = (long)AccurateMath.floor((d + tol) * nm);
+        long upperBound = (long)JdkMath.ceil((d - tol) * nm);
+        long lowerBound = (long)JdkMath.floor((d + tol) * nm);
         if (strict && lowerBound == upperBound) {
             return upperBound + 1L;
         } else {
@@ -961,7 +961,7 @@
      *         \(D_{n,m}\) greater than {@code d}
      */
     public double approximateP(double d, int n, int m) {
-        return 1 - ksSum(d * AccurateMath.sqrt(((double) m * (double) n) / ((double) m + (double) n)),
+        return 1 - ksSum(d * JdkMath.sqrt(((double) m * (double) n) / ((double) m + (double) n)),
                          KS_SUM_CAUCHY_CRITERION, MAXIMUM_PARTIAL_SUM_COUNT);
     }
 
@@ -1036,8 +1036,8 @@
                                        final int iterations,
                                        UniformRandomProvider rng) {
         // ensure that nn is always the max of (n, m) to require fewer random numbers
-        final int nn = AccurateMath.max(n, m);
-        final int mm = AccurateMath.min(n, m);
+        final int nn = JdkMath.max(n, m);
+        final int mm = JdkMath.min(n, m);
         final int sum = nn + mm;
 
         int tail = 0;
@@ -1178,9 +1178,9 @@
      */
     private static int c(int i, int j, int m, int n, long cmn, boolean strict) {
         if (strict) {
-            return AccurateMath.abs(i*(long)n - j*(long)m) <= cmn ? 1 : 0;
+            return JdkMath.abs(i*(long)n - j*(long)m) <= cmn ? 1 : 0;
         }
-        return AccurateMath.abs(i*(long)n - j*(long)m) < cmn ? 1 : 0;
+        return JdkMath.abs(i*(long)n - j*(long)m) < cmn ? 1 : 0;
     }
 
     /**
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/MannWhitneyUTest.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/MannWhitneyUTest.java
index 2f1cdd3..8e9b52c 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/MannWhitneyUTest.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/MannWhitneyUTest.java
@@ -24,7 +24,7 @@
 import org.apache.commons.math4.legacy.stat.ranking.NaNStrategy;
 import org.apache.commons.math4.legacy.stat.ranking.NaturalRanking;
 import org.apache.commons.math4.legacy.stat.ranking.TiesStrategy;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 import java.util.stream.IntStream;
 
@@ -150,7 +150,7 @@
          */
         final double u2 = (long) x.length * y.length - u1;
 
-        return AccurateMath.min(u1, u2);
+        return JdkMath.min(u1, u2);
     }
 
     /**
@@ -177,7 +177,7 @@
         final double eU = n1n2prod / 2.0;
         final double varU = n1n2prod * (n1 + n2 + 1) / 12.0;
 
-        final double z = (umin - eU) / AccurateMath.sqrt(varU);
+        final double z = (umin - eU) / JdkMath.sqrt(varU);
 
         // No try-catch or advertised exception because args are valid
         // pass a null rng to avoid unneeded overhead as we will not sample from this distribution
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/TTest.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/TTest.java
index be4dc90..f80aeca 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/TTest.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/TTest.java
@@ -28,7 +28,7 @@
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
 import org.apache.commons.math4.legacy.stat.StatUtils;
 import org.apache.commons.math4.legacy.stat.descriptive.StatisticalSummary;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * An implementation for Student's t-tests.
@@ -999,7 +999,7 @@
      */
     protected double t(final double m, final double mu,
                        final double v, final double n) {
-        return (m - mu) / AccurateMath.sqrt(v / n);
+        return (m - mu) / JdkMath.sqrt(v / n);
     }
 
     /**
@@ -1018,7 +1018,7 @@
     protected double t(final double m1, final double m2,
                        final double v1, final double v2,
                        final double n1, final double n2)  {
-        return (m1 - m2) / AccurateMath.sqrt((v1 / n1) + (v2 / n2));
+        return (m1 - m2) / JdkMath.sqrt((v1 / n1) + (v2 / n2));
     }
 
     /**
@@ -1037,7 +1037,7 @@
                                     final double v1, final double v2,
                                     final double n1, final double n2)  {
         final double pooledVariance = ((n1  - 1) * v1 + (n2 -1) * v2 ) / (n1 + n2 - 2);
-        return (m1 - m2) / AccurateMath.sqrt(pooledVariance * (1d / n1 + 1d / n2));
+        return (m1 - m2) / JdkMath.sqrt(pooledVariance * (1d / n1 + 1d / n2));
     }
 
     /**
@@ -1055,7 +1055,7 @@
                            final double v, final double n)
         throws MaxCountExceededException, MathIllegalArgumentException {
 
-        final double t = AccurateMath.abs(t(m, mu, v, n));
+        final double t = JdkMath.abs(t(m, mu, v, n));
         // pass a null rng to avoid unneeded overhead as we will not sample from this distribution
         final TDistribution distribution = TDistribution.of(n - 1);
         return 2.0 * distribution.cumulativeProbability(-t);
@@ -1084,7 +1084,7 @@
                            final double n1, final double n2)
         throws MaxCountExceededException, NotStrictlyPositiveException {
 
-        final double t = AccurateMath.abs(t(m1, m2, v1, v2, n1, n2));
+        final double t = JdkMath.abs(t(m1, m2, v1, v2, n1, n2));
         final double degreesOfFreedom = df(v1, v2, n1, n2);
         // pass a null rng to avoid unneeded overhead as we will not sample from this distribution
         final TDistribution distribution = TDistribution.of(degreesOfFreedom);
@@ -1114,7 +1114,7 @@
                                         double n1, double n2)
         throws MaxCountExceededException, NotStrictlyPositiveException {
 
-        final double t = AccurateMath.abs(homoscedasticT(m1, m2, v1, v2, n1, n2));
+        final double t = JdkMath.abs(homoscedasticT(m1, m2, v1, v2, n1, n2));
         final double degreesOfFreedom = n1 + n2 - 2;
         // pass a null rng to avoid unneeded overhead as we will not sample from this distribution
         final TDistribution distribution = TDistribution.of(degreesOfFreedom);
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/WilcoxonSignedRankTest.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/WilcoxonSignedRankTest.java
index 0d1fdd4..2f0b4c9 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/WilcoxonSignedRankTest.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/inference/WilcoxonSignedRankTest.java
@@ -26,7 +26,7 @@
 import org.apache.commons.math4.legacy.stat.ranking.NaNStrategy;
 import org.apache.commons.math4.legacy.stat.ranking.NaturalRanking;
 import org.apache.commons.math4.legacy.stat.ranking.TiesStrategy;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * An implementation of the Wilcoxon signed-rank test.
@@ -127,7 +127,7 @@
         final double[] zAbs = new double[z.length];
 
         for (int i = 0; i < z.length; ++i) {
-            zAbs[i] = AccurateMath.abs(z[i]);
+            zAbs[i] = JdkMath.abs(z[i]);
         }
 
         return zAbs;
@@ -190,7 +190,7 @@
         final int n = x.length;
         final double wMinus = (((double) (n * (n + 1))) / 2.0) - wPlus;
 
-        return AccurateMath.max(wPlus, wMinus);
+        return JdkMath.max(wPlus, wMinus);
     }
 
     /**
@@ -249,7 +249,7 @@
         final double varS = es * ((double) (2 * n + 1) / 6.0);
 
         // - 0.5 is a continuity correction
-        final double z = (wMin - es - 0.5) / AccurateMath.sqrt(varS);
+        final double z = (wMin - es - 0.5) / JdkMath.sqrt(varS);
 
         // No try-catch or advertised exception because args are valid
         // pass a null rng to avoid unneeded overhead as we will not sample from this distribution
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/interval/AgrestiCoullInterval.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/interval/AgrestiCoullInterval.java
index 2e60415..54059fe 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/interval/AgrestiCoullInterval.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/interval/AgrestiCoullInterval.java
@@ -17,7 +17,7 @@
 package org.apache.commons.math4.legacy.stat.interval;
 
 import org.apache.commons.statistics.distribution.NormalDistribution;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Implements the Agresti-Coull method for creating a binomial proportion confidence interval.
@@ -36,11 +36,11 @@
         final double alpha = (1.0 - confidenceLevel) / 2;
         final NormalDistribution normalDistribution = NormalDistribution.of(0, 1);
         final double z = normalDistribution.inverseCumulativeProbability(1 - alpha);
-        final double zSquared = AccurateMath.pow(z, 2);
+        final double zSquared = JdkMath.pow(z, 2);
         final double modifiedNumberOfTrials = numberOfTrials + zSquared;
         final double modifiedSuccessesRatio = (1.0 / modifiedNumberOfTrials) * (numberOfSuccesses + 0.5 * zSquared);
         final double difference = z *
-                                  AccurateMath.sqrt(1.0 / modifiedNumberOfTrials * modifiedSuccessesRatio *
+                                  JdkMath.sqrt(1.0 / modifiedNumberOfTrials * modifiedSuccessesRatio *
                                                 (1 - modifiedSuccessesRatio));
         return new ConfidenceInterval(modifiedSuccessesRatio - difference, modifiedSuccessesRatio + difference,
                                       confidenceLevel);
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/interval/NormalApproximationInterval.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/interval/NormalApproximationInterval.java
index c9e4832..c85e653 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/interval/NormalApproximationInterval.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/interval/NormalApproximationInterval.java
@@ -17,7 +17,7 @@
 package org.apache.commons.math4.legacy.stat.interval;
 
 import org.apache.commons.statistics.distribution.NormalDistribution;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Implements the normal approximation method for creating a binomial proportion confidence interval.
@@ -38,7 +38,7 @@
         final double alpha = (1.0 - confidenceLevel) / 2;
         final NormalDistribution normalDistribution = NormalDistribution.of(0, 1);
         final double difference = normalDistribution.inverseCumulativeProbability(1 - alpha) *
-                                  AccurateMath.sqrt(1.0 / numberOfTrials * mean * (1 - mean));
+                                  JdkMath.sqrt(1.0 / numberOfTrials * mean * (1 - mean));
         return new ConfidenceInterval(mean - difference, mean + difference, confidenceLevel);
     }
 
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/interval/WilsonScoreInterval.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/interval/WilsonScoreInterval.java
index 0fa89ec..e08d587 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/interval/WilsonScoreInterval.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/interval/WilsonScoreInterval.java
@@ -17,7 +17,7 @@
 package org.apache.commons.math4.legacy.stat.interval;
 
 import org.apache.commons.statistics.distribution.NormalDistribution;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Implements the <a href="http://en.wikipedia.org/wiki/Binomial_proportion_confidence_interval#Wilson_score_interval">
@@ -41,7 +41,7 @@
 
         final double factor = 1 / (1 + zSquaredOverNumTrials);
         final double modifiedSuccessRatio = mean + zSquaredOverNumTrials / 2;
-        final double difference = z * AccurateMath.sqrt(oneOverNumTrials * mean * (1 - mean) +
+        final double difference = z * JdkMath.sqrt(oneOverNumTrials * mean * (1 - mean) +
                                                     (oneOverNumTrials * zSquaredOverNumTrials / 4));
 
         final double lowerBound = factor * (modifiedSuccessRatio - difference);
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/ranking/NaturalRanking.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/ranking/NaturalRanking.java
index 49116c1..d1103fe 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/ranking/NaturalRanking.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/ranking/NaturalRanking.java
@@ -27,7 +27,7 @@
 import org.apache.commons.rng.sampling.distribution.UniformLongSampler;
 import org.apache.commons.math4.legacy.exception.MathInternalError;
 import org.apache.commons.math4.legacy.exception.NotANumberException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 
 /**
@@ -353,7 +353,7 @@
                 break;
             case RANDOM:    // Fill with random integral values in [c, c + length - 1]
                 Iterator<Integer> iterator = tiesTrace.iterator();
-                long f = AccurateMath.round(c);
+                long f = JdkMath.round(c);
                 final UniformLongSampler sampler = UniformLongSampler.of(random, f, f + length - 1);
                 while (iterator.hasNext()) {
                     // No advertised exception because args are guaranteed valid
@@ -363,7 +363,7 @@
             case SEQUENTIAL:  // Fill sequentially from c to c + length - 1
                 // walk and fill
                 iterator = tiesTrace.iterator();
-                f = AccurateMath.round(c);
+                f = JdkMath.round(c);
                 int i = 0;
                 while (iterator.hasNext()) {
                     ranks[iterator.next()] = f + i++;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/regression/AbstractMultipleLinearRegression.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/regression/AbstractMultipleLinearRegression.java
index dae6f40..006a2b9 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/regression/AbstractMultipleLinearRegression.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/regression/AbstractMultipleLinearRegression.java
@@ -28,7 +28,7 @@
 import org.apache.commons.math4.legacy.linear.RealMatrix;
 import org.apache.commons.math4.legacy.linear.RealVector;
 import org.apache.commons.math4.legacy.stat.descriptive.moment.Variance;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Abstract base class for implementations of MultipleLinearRegression.
@@ -292,7 +292,7 @@
         int length = betaVariance[0].length;
         double[] result = new double[length];
         for (int i = 0; i < length; i++) {
-            result[i] = AccurateMath.sqrt(sigma * betaVariance[i][i]);
+            result[i] = JdkMath.sqrt(sigma * betaVariance[i][i]);
         }
         return result;
     }
@@ -323,7 +323,7 @@
      * @since 2.2
      */
     public double estimateRegressionStandardError() {
-        return AccurateMath.sqrt(estimateErrorVariance());
+        return JdkMath.sqrt(estimateErrorVariance());
     }
 
     /**
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/regression/MillerUpdatingRegression.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/regression/MillerUpdatingRegression.java
index 7adebc4..42db0bd 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/regression/MillerUpdatingRegression.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/regression/MillerUpdatingRegression.java
@@ -19,7 +19,7 @@
 import java.util.Arrays;
 
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.numbers.core.Precision;
 
 /**
@@ -258,7 +258,7 @@
             if (di != 0.0) {
                 dpi = smartAdd(di, wxi * xi);
                 final double tmp = wxi * xi / di;
-                if (AccurateMath.abs(tmp) > Precision.EPSILON) {
+                if (JdkMath.abs(tmp) > Precision.EPSILON) {
                     w = (di * w) / dpi;
                 }
             } else {
@@ -295,8 +295,8 @@
      * @return the sum of the a and b
      */
     private double smartAdd(double a, double b) {
-        final double aa = AccurateMath.abs(a);
-        final double ba = AccurateMath.abs(b);
+        final double aa = JdkMath.abs(a);
+        final double ba = JdkMath.abs(b);
         if (aa > ba) {
             final double eps = aa * Precision.EPSILON;
             if (ba > eps) {
@@ -346,14 +346,14 @@
         double total;
         final double eps = this.epsilon;
         for (int i = 0; i < nvars; i++) {
-            this.workTolset[i] = AccurateMath.sqrt(d[i]);
+            this.workTolset[i] = JdkMath.sqrt(d[i]);
         }
         tol[0] = eps * this.workTolset[0];
         for (int col = 1; col < nvars; col++) {
             pos = col - 1;
             total = workTolset[col];
             for (int row = 0; row < col; row++) {
-                total += AccurateMath.abs(r[pos]) * workTolset[row];
+                total += JdkMath.abs(r[pos]) * workTolset[row];
                 pos += nvars - row - 2;
             }
             tol[col] = eps * total;
@@ -387,7 +387,7 @@
         final double[] ret = new double[nreq];
         boolean rankProblem = false;
         for (int i = nreq - 1; i > -1; i--) {
-            if (AccurateMath.sqrt(d[i]) < tol[i]) {
+            if (JdkMath.sqrt(d[i]) < tol[i]) {
                 ret[i] = 0.0;
                 d[i] = 0.0;
                 rankProblem = true;
@@ -417,7 +417,7 @@
     private void singcheck() {
         int pos;
         for (int i = 0; i < nvars; i++) {
-            workSing[i] = AccurateMath.sqrt(d[i]);
+            workSing[i] = JdkMath.sqrt(d[i]);
         }
         for (int col = 0; col < nvars; col++) {
             // Set elements within R to zero if they are less than tol(col) in
@@ -426,7 +426,7 @@
             final double temp = tol[col];
             pos = col - 1;
             for (int row = 0; row < col - 1; row++) {
-                if (AccurateMath.abs(r[pos]) * workSing[row] < temp) {
+                if (JdkMath.abs(r[pos]) * workSing[row] < temp) {
                     r[pos] = 0.0;
                 }
                 pos += nvars - row - 2;
@@ -629,7 +629,7 @@
         final int nvm = nvars - 1;
         final int basePos = r.length - (nvm - in) * (nvm - in + 1) / 2;
         if (d[in] > 0.0) {
-            rms[in + rmsOff] = 1.0 / AccurateMath.sqrt(d[in]);
+            rms[in + rmsOff] = 1.0 / JdkMath.sqrt(d[in]);
         }
         for (int col = in + 1; col < nvars; col++) {
             pos = basePos + col - 1 - in;
@@ -639,7 +639,7 @@
                 pos += nvars - row - 2;
             }
             if (sumxx > 0.0) {
-                rms[col + rmsOff] = 1.0 / AccurateMath.sqrt(sumxx);
+                rms[col + rmsOff] = 1.0 / JdkMath.sqrt(sumxx);
             } else {
                 rms[col + rmsOff] = 0.0;
             }
@@ -649,7 +649,7 @@
             sumyy += d[row] * rhs[row] * rhs[row];
         }
         if (sumyy > 0.0) {
-            sumyy = 1.0 / AccurateMath.sqrt(sumyy);
+            sumyy = 1.0 / JdkMath.sqrt(sumyy);
         }
         pos = 0;
         for (int col1 = in; col1 < nvars; col1++) {
@@ -733,10 +733,10 @@
             // Special cases.
             if (d1 > this.epsilon || d2 > this.epsilon) {
                 x = r[m1];
-                if (AccurateMath.abs(x) * AccurateMath.sqrt(d1) < tol[mp1]) {
+                if (JdkMath.abs(x) * JdkMath.sqrt(d1) < tol[mp1]) {
                     x = 0.0;
                 }
-                if (d1 < this.epsilon || AccurateMath.abs(x) < this.epsilon) {
+                if (d1 < this.epsilon || JdkMath.abs(x) < this.epsilon) {
                     d[m] = d2;
                     d[mp1] = d1;
                     r[m1] = 0.0;
@@ -872,7 +872,7 @@
         }
         double hii = 0.0;
         for (int col = 0; col < xrow.length; col++) {
-            if (AccurateMath.sqrt(d[col]) < tol[col]) {
+            if (JdkMath.sqrt(d[col]) < tol[col]) {
                 wk[col] = 0.0;
             } else {
                 pos = col - 1;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/regression/RegressionResults.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/regression/RegressionResults.java
index 2d7fbd6..030c99a 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/regression/RegressionResults.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/regression/RegressionResults.java
@@ -20,7 +20,7 @@
 import java.util.Arrays;
 
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 
 /**
  * Results of a Multiple Linear Regression model fit.
@@ -192,7 +192,7 @@
         }
         double var = this.getVcvElement(index, index);
         if (!Double.isNaN(var) && var > Double.MIN_VALUE) {
-            return AccurateMath.sqrt(var);
+            return JdkMath.sqrt(var);
         }
         return Double.NaN;
     }
@@ -216,7 +216,7 @@
         for (int i = 0; i < this.parameters.length; i++) {
             double var = this.getVcvElement(i, i);
             if (!Double.isNaN(var) && var > Double.MIN_VALUE) {
-                se[i] = AccurateMath.sqrt(var);
+                se[i] = JdkMath.sqrt(var);
                 continue;
             }
             se[i] = Double.NaN;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/regression/SimpleRegression.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/regression/SimpleRegression.java
index 981f14d..b53bd4f 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/regression/SimpleRegression.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/regression/SimpleRegression.java
@@ -23,7 +23,7 @@
 import org.apache.commons.math4.legacy.exception.NoDataException;
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.numbers.core.Precision;
 
 /**
@@ -438,7 +438,7 @@
         if (n < 2) {
             return Double.NaN; //not enough data
         }
-        if (AccurateMath.abs(sumXX) < 10 * Double.MIN_VALUE) {
+        if (JdkMath.abs(sumXX) < 10 * Double.MIN_VALUE) {
             return Double.NaN; //not enough variation in x
         }
         return sumXY / sumXX;
@@ -474,7 +474,7 @@
      * @return sum of squared errors associated with the regression model
      */
     public double getSumSquaredErrors() {
-        return AccurateMath.max(0d, sumYY - sumXY * sumXY / sumXX);
+        return JdkMath.max(0d, sumYY - sumXY * sumXY / sumXX);
     }
 
     /**
@@ -570,7 +570,7 @@
      */
     public double getR() {
         double b1 = getSlope();
-        double result = AccurateMath.sqrt(getRSquare());
+        double result = JdkMath.sqrt(getRSquare());
         if (b1 < 0) {
             result = -result;
         }
@@ -612,7 +612,7 @@
         if( !hasIntercept ){
             return Double.NaN;
         }
-        return AccurateMath.sqrt(
+        return JdkMath.sqrt(
             getMeanSquareError() * ((1d / n) + (xbar * xbar) / sumXX));
     }
 
@@ -628,7 +628,7 @@
      * @return standard error associated with slope estimate
      */
     public double getSlopeStdErr() {
-        return AccurateMath.sqrt(getMeanSquareError() / sumXX);
+        return JdkMath.sqrt(getMeanSquareError() / sumXX);
     }
 
     /**
@@ -732,7 +732,7 @@
         // No advertised NotStrictlyPositiveException here - will return NaN above
         TDistribution distribution = TDistribution.of(n - 2d);
         return 2d * (1.0 - distribution.cumulativeProbability(
-                    AccurateMath.abs(getSlope()) / getSlopeStdErr()));
+                    JdkMath.abs(getSlope()) / getSlopeStdErr()));
     }
 
     // ---------------------Private methods-----------------------------------
@@ -780,7 +780,7 @@
             if (n < 3) {
                 throw new NoDataException(LocalizedFormats.NOT_ENOUGH_DATA_REGRESSION);
             }
-            if (AccurateMath.abs(sumXX) > Precision.SAFE_MIN) {
+            if (JdkMath.abs(sumXX) > Precision.SAFE_MIN) {
                 final double[] params = new double[] { getIntercept(), getSlope() };
                 final double mse = getMeanSquareError();
                 final double syy = sumYY + sumY * sumY / n;
@@ -860,7 +860,7 @@
                     //final double _syy = sumYY + sumY * sumY / ((double) n);
                     final double sxx = sumXX + sumX * sumX / n;
                     final double sxy = sumXY + sumX * sumY / n;
-                    final double sse = AccurateMath.max(0d, syy - sxy * sxy / sxx);
+                    final double sse = JdkMath.max(0d, syy - sxy * sxy / sxx);
                     final double mse = sse/((n-1));
                     if( !Double.isNaN(sxx) ){
                         final double[] vcv = new double[]{ mse / sxx };
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/TestUtils.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/TestUtils.java
index 5939cc5..b6f8f28 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/TestUtils.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/TestUtils.java
@@ -29,7 +29,7 @@
 import org.apache.commons.numbers.core.Precision;
 import org.apache.commons.statistics.distribution.ContinuousDistribution;
 import org.apache.commons.math4.legacy.core.FieldElement;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.math4.legacy.util.ComplexFormat;
 import org.apache.commons.math4.legacy.linear.FieldMatrix;
 import org.apache.commons.math4.legacy.linear.RealMatrix;
@@ -171,7 +171,7 @@
         } else if (expected == 0.0) {
             Assert.assertEquals(msg, actual, expected, relativeError);
         } else {
-            double absError = AccurateMath.abs(expected) * relativeError;
+            double absError = JdkMath.abs(expected) * relativeError;
             Assert.assertEquals(msg, expected, actual, absError);
         }
     }
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/FunctionUtilsTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/FunctionUtilsTest.java
index f39e7b3..8dbe44a 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/FunctionUtilsTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/FunctionUtilsTest.java
@@ -38,7 +38,7 @@
 import org.apache.commons.math4.legacy.analysis.function.Sinc;
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -46,7 +46,7 @@
  * Test for {@link FunctionUtils}.
  */
 public class FunctionUtilsTest {
-    private final double EPS = AccurateMath.ulp(1d);
+    private final double EPS = JdkMath.ulp(1d);
 
     @Test
     public void testCompose() {
@@ -113,7 +113,7 @@
         UnivariateDifferentiableFunction inv = new Inverse();
 
         final double a = 123.456;
-        Assert.assertEquals(- 1 / (a * a) -1 + AccurateMath.cos(a),
+        Assert.assertEquals(- 1 / (a * a) -1 + JdkMath.cos(a),
                             FunctionUtils.add(inv, m, c, sin).value(new DerivativeStructure(1, 1, 0, a)).getPartialDerivative(1),
                             EPS);
     }
@@ -138,11 +138,11 @@
         UnivariateDifferentiableFunction inv = new Inverse();
         UnivariateDifferentiableFunction pow = new Power(2.5);
         UnivariateDifferentiableFunction cos = new Cos();
-        Assert.assertEquals(1.5 * AccurateMath.sqrt(a) * AccurateMath.cos(a) - AccurateMath.pow(a, 1.5) * AccurateMath.sin(a),
+        Assert.assertEquals(1.5 * JdkMath.sqrt(a) * JdkMath.cos(a) - JdkMath.pow(a, 1.5) * JdkMath.sin(a),
                             FunctionUtils.multiply(inv, pow, cos).value(new DerivativeStructure(1, 1, 0, a)).getPartialDerivative(1), EPS);
 
         UnivariateDifferentiableFunction cosh = new Cosh();
-        Assert.assertEquals(1.5 * AccurateMath.sqrt(a) * AccurateMath.cosh(a) + AccurateMath.pow(a, 1.5) * AccurateMath.sinh(a),
+        Assert.assertEquals(1.5 * JdkMath.sqrt(a) * JdkMath.cosh(a) + JdkMath.pow(a, 1.5) * JdkMath.sinh(a),
                             FunctionUtils.multiply(inv, pow, cosh).value(new DerivativeStructure(1, 1, 0, a)).getPartialDerivative(1), 8 * EPS);
     }
 
@@ -188,7 +188,7 @@
         UnivariateFunction sinc2 = new Sinc();
 
         for (int i = 0; i < 10; i++) {
-            double x = AccurateMath.random();
+            double x = JdkMath.random();
             Assert.assertEquals(sinc1.value(x), sinc2.value(x), EPS);
         }
     }
@@ -202,7 +202,7 @@
         UnivariateFunction pow2 = FunctionUtils.fix2ndArgument(new Pow(), 2);
 
         for (int i = 0; i < 10; i++) {
-            double x = AccurateMath.random() * 10;
+            double x = JdkMath.random() * 10;
             Assert.assertEquals(pow1.value(x), pow2.value(x), 0);
         }
     }
@@ -234,10 +234,10 @@
             // x = sin(t)
             DerivativeStructure dsT = new DerivativeStructure(1, 2, 0, t);
             DerivativeStructure y = f.value(dsT.sin());
-            Assert.assertEquals(AccurateMath.sin(t) * AccurateMath.sin(t),               f.value(AccurateMath.sin(t)),  1.0e-15);
-            Assert.assertEquals(AccurateMath.sin(t) * AccurateMath.sin(t),               y.getValue(),              1.0e-15);
-            Assert.assertEquals(2 * AccurateMath.cos(t) * AccurateMath.sin(t),           y.getPartialDerivative(1), 1.0e-15);
-            Assert.assertEquals(2 * (1 - 2 * AccurateMath.sin(t) * AccurateMath.sin(t)), y.getPartialDerivative(2), 1.0e-15);
+            Assert.assertEquals(JdkMath.sin(t) * JdkMath.sin(t),               f.value(JdkMath.sin(t)),  1.0e-15);
+            Assert.assertEquals(JdkMath.sin(t) * JdkMath.sin(t),               y.getValue(),              1.0e-15);
+            Assert.assertEquals(2 * JdkMath.cos(t) * JdkMath.sin(t),           y.getPartialDerivative(1), 1.0e-15);
+            Assert.assertEquals(2 * (1 - 2 * JdkMath.sin(t) * JdkMath.sin(t)), y.getPartialDerivative(2), 1.0e-15);
         }
 
         try {
@@ -272,8 +272,8 @@
             // x = sin(t), y = cos(t), hence the method really becomes univariate
             DerivativeStructure dsT = new DerivativeStructure(1, 1, 0, t);
             DerivativeStructure y = mdf.value(new DerivativeStructure[] { dsT.sin(), dsT.cos() });
-            Assert.assertEquals(a * AccurateMath.sin(t) + b * AccurateMath.cos(t), y.getValue(),              1.0e-15);
-            Assert.assertEquals(a * AccurateMath.cos(t) - b * AccurateMath.sin(t), y.getPartialDerivative(1), 1.0e-15);
+            Assert.assertEquals(a * JdkMath.sin(t) + b * JdkMath.cos(t), y.getValue(),              1.0e-15);
+            Assert.assertEquals(a * JdkMath.cos(t) - b * JdkMath.sin(t), y.getPartialDerivative(1), 1.0e-15);
         }
 
         for (double u = -1.0; u < 1; u += 0.01) {
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/DerivativeStructureTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/DerivativeStructureTest.java
index 91811d8..941dd66 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/DerivativeStructureTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/DerivativeStructureTest.java
@@ -29,7 +29,7 @@
 import org.apache.commons.rng.simple.RandomSource;
 import org.apache.commons.numbers.core.ArithmeticUtils;
 import org.apache.commons.numbers.combinatorics.Factorial;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.numbers.core.Precision;
 import org.junit.Assert;
 import org.junit.Test;
@@ -86,8 +86,8 @@
     @Test
     public void testConstant() {
         for (int maxOrder = 1; maxOrder < 5; ++maxOrder) {
-            checkF0F1(new DerivativeStructure(3, maxOrder, AccurateMath.PI),
-                      AccurateMath.PI, 0.0, 0.0, 0.0);
+            checkF0F1(new DerivativeStructure(3, maxOrder, JdkMath.PI),
+                      JdkMath.PI, 0.0, 0.0, 0.0);
         }
     }
 
@@ -188,8 +188,8 @@
             Assert.assertEquals(1 / x, r.getValue(), 1.0e-15);
             for (int i = 1; i < r.getOrder(); ++i) {
                 double expected = ArithmeticUtils.pow(-1, i) * Factorial.value(i) /
-                                  AccurateMath.pow(x, i + 1);
-                Assert.assertEquals(expected, r.getPartialDerivative(i), 1.0e-15 * AccurateMath.abs(expected));
+                                  JdkMath.pow(x, i + 1);
+                Assert.assertEquals(expected, r.getPartialDerivative(i), 1.0e-15 * JdkMath.abs(expected));
             }
         }
     }
@@ -266,7 +266,7 @@
             Assert.assertTrue(Double.isNaN(zeroNeg.getPartialDerivative(1, 0, 0)));
             DerivativeStructure posNeg = DerivativeStructure.pow(2.0, new DerivativeStructure(3,  maxOrder, 0, -2.0));
             Assert.assertEquals(1.0 / 4.0, posNeg.getValue(), 1.0e-15);
-            Assert.assertEquals(AccurateMath.log(2.0) / 4.0, posNeg.getPartialDerivative(1, 0, 0), 1.0e-15);
+            Assert.assertEquals(JdkMath.log(2.0) / 4.0, posNeg.getPartialDerivative(1, 0, 0), 1.0e-15);
 
             // very special case: a = 0 and power = 0
             DerivativeStructure zeroZero = DerivativeStructure.pow(0.0, new DerivativeStructure(3,  maxOrder, 0, 0.0));
@@ -382,32 +382,32 @@
                                                     5, dsX.multiply(dsY),
                                                     -2, dsZ).add(new DerivativeStructure(8, dsZ.multiply(dsX),
                                                                                          -1, dsY).pow(3));
-                    double f = x + 5 * x * y - 2 * z + AccurateMath.pow(8 * z * x - y, 3);
+                    double f = x + 5 * x * y - 2 * z + JdkMath.pow(8 * z * x - y, 3);
                     Assert.assertEquals(f, ds.getValue(),
-                                        AccurateMath.abs(epsilon * f));
+                                        JdkMath.abs(epsilon * f));
                     Assert.assertEquals(f, dsOther.getValue(),
-                                        AccurateMath.abs(epsilon * f));
+                                        JdkMath.abs(epsilon * f));
 
                     // df/dx = 1 + 5 y + 24 (8 z x - y)^2 z
-                    double dfdx = 1 + 5 * y + 24 * z * AccurateMath.pow(8 * z * x - y, 2);
+                    double dfdx = 1 + 5 * y + 24 * z * JdkMath.pow(8 * z * x - y, 2);
                     Assert.assertEquals(dfdx, ds.getPartialDerivative(1, 0, 0),
-                                        AccurateMath.abs(epsilon * dfdx));
+                                        JdkMath.abs(epsilon * dfdx));
                     Assert.assertEquals(dfdx, dsOther.getPartialDerivative(1, 0, 0),
-                                        AccurateMath.abs(epsilon * dfdx));
+                                        JdkMath.abs(epsilon * dfdx));
 
                     // df/dxdy = 5 + 48 z*(y - 8 z x)
                     double dfdxdy = 5 + 48 * z * (y - 8 * z * x);
                     Assert.assertEquals(dfdxdy, ds.getPartialDerivative(1, 1, 0),
-                                        AccurateMath.abs(epsilon * dfdxdy));
+                                        JdkMath.abs(epsilon * dfdxdy));
                     Assert.assertEquals(dfdxdy, dsOther.getPartialDerivative(1, 1, 0),
-                                        AccurateMath.abs(epsilon * dfdxdy));
+                                        JdkMath.abs(epsilon * dfdxdy));
 
                     // df/dxdydz = 48 (y - 16 z x)
                     double dfdxdydz = 48 * (y - 16 * z * x);
                     Assert.assertEquals(dfdxdydz, ds.getPartialDerivative(1, 1, 1),
-                                        AccurateMath.abs(epsilon * dfdxdydz));
+                                        JdkMath.abs(epsilon * dfdxdydz));
                     Assert.assertEquals(dfdxdydz, dsOther.getPartialDerivative(1, 1, 1),
-                                        AccurateMath.abs(epsilon * dfdxdydz));
+                                        JdkMath.abs(epsilon * dfdxdydz));
 
                 }
 
@@ -424,17 +424,17 @@
                 for (double y = 0.1; y < 1.2; y += 0.1) {
                     DerivativeStructure dsY = new DerivativeStructure(1, maxOrder, y);
                     DerivativeStructure f = dsX.divide(dsY).sqrt();
-                    double f0 = AccurateMath.sqrt(x / y);
-                    Assert.assertEquals(f0, f.getValue(), AccurateMath.abs(epsilon * f0));
+                    double f0 = JdkMath.sqrt(x / y);
+                    Assert.assertEquals(f0, f.getValue(), JdkMath.abs(epsilon * f0));
                     if (f.getOrder() > 0) {
-                        double f1 = 1 / (2 * AccurateMath.sqrt(x * y));
-                        Assert.assertEquals(f1, f.getPartialDerivative(1), AccurateMath.abs(epsilon * f1));
+                        double f1 = 1 / (2 * JdkMath.sqrt(x * y));
+                        Assert.assertEquals(f1, f.getPartialDerivative(1), JdkMath.abs(epsilon * f1));
                         if (f.getOrder() > 1) {
                             double f2 = -f1 / (2 * x);
-                            Assert.assertEquals(f2, f.getPartialDerivative(2), AccurateMath.abs(epsilon * f2));
+                            Assert.assertEquals(f2, f.getPartialDerivative(2), JdkMath.abs(epsilon * f2));
                             if (f.getOrder() > 2) {
                                 double f3 = (f0 + x / (2 * y * f0)) / (4 * x * x * x);
-                                Assert.assertEquals(f3, f.getPartialDerivative(3), AccurateMath.abs(epsilon * f3));
+                                Assert.assertEquals(f3, f.getPartialDerivative(3), JdkMath.abs(epsilon * f3));
                             }
                         }
                     }
@@ -454,30 +454,30 @@
                     for (double z = 0.1; z < 1.2; z += 0.1) {
                         DerivativeStructure dsZ = new DerivativeStructure(3, maxOrder, 2, z);
                         DerivativeStructure f = dsX.divide(dsY.cos().add(dsZ.tan())).sin();
-                        double a = AccurateMath.cos(y) + AccurateMath.tan(z);
-                        double f0 = AccurateMath.sin(x / a);
-                        Assert.assertEquals(f0, f.getValue(), AccurateMath.abs(epsilon * f0));
+                        double a = JdkMath.cos(y) + JdkMath.tan(z);
+                        double f0 = JdkMath.sin(x / a);
+                        Assert.assertEquals(f0, f.getValue(), JdkMath.abs(epsilon * f0));
                         if (f.getOrder() > 0) {
-                            double dfdx = AccurateMath.cos(x / a) / a;
-                            Assert.assertEquals(dfdx, f.getPartialDerivative(1, 0, 0), AccurateMath.abs(epsilon * dfdx));
-                            double dfdy =  x * AccurateMath.sin(y) * dfdx / a;
-                            Assert.assertEquals(dfdy, f.getPartialDerivative(0, 1, 0), AccurateMath.abs(epsilon * dfdy));
-                            double cz = AccurateMath.cos(z);
+                            double dfdx = JdkMath.cos(x / a) / a;
+                            Assert.assertEquals(dfdx, f.getPartialDerivative(1, 0, 0), JdkMath.abs(epsilon * dfdx));
+                            double dfdy =  x * JdkMath.sin(y) * dfdx / a;
+                            Assert.assertEquals(dfdy, f.getPartialDerivative(0, 1, 0), JdkMath.abs(epsilon * dfdy));
+                            double cz = JdkMath.cos(z);
                             double cz2 = cz * cz;
                             double dfdz = -x * dfdx / (a * cz2);
-                            Assert.assertEquals(dfdz, f.getPartialDerivative(0, 0, 1), AccurateMath.abs(epsilon * dfdz));
+                            Assert.assertEquals(dfdz, f.getPartialDerivative(0, 0, 1), JdkMath.abs(epsilon * dfdz));
                             if (f.getOrder() > 1) {
                                 double df2dx2 = -(f0 / (a * a));
-                                Assert.assertEquals(df2dx2, f.getPartialDerivative(2, 0, 0), AccurateMath.abs(epsilon * df2dx2));
-                                double df2dy2 = x * AccurateMath.cos(y) * dfdx / a -
-                                                x * x * AccurateMath.sin(y) * AccurateMath.sin(y) * f0 / (a * a * a * a) +
-                                                2 * AccurateMath.sin(y) * dfdy / a;
-                                Assert.assertEquals(df2dy2, f.getPartialDerivative(0, 2, 0), AccurateMath.abs(epsilon * df2dy2));
+                                Assert.assertEquals(df2dx2, f.getPartialDerivative(2, 0, 0), JdkMath.abs(epsilon * df2dx2));
+                                double df2dy2 = x * JdkMath.cos(y) * dfdx / a -
+                                                x * x * JdkMath.sin(y) * JdkMath.sin(y) * f0 / (a * a * a * a) +
+                                                2 * JdkMath.sin(y) * dfdy / a;
+                                Assert.assertEquals(df2dy2, f.getPartialDerivative(0, 2, 0), JdkMath.abs(epsilon * df2dy2));
                                 double c4 = cz2 * cz2;
-                                double df2dz2 = x * (2 * a * (1 - a * cz * AccurateMath.sin(z)) * dfdx - x * f0 / a ) / (a * a * a * c4);
-                                Assert.assertEquals(df2dz2, f.getPartialDerivative(0, 0, 2), AccurateMath.abs(epsilon * df2dz2));
-                                double df2dxdy = dfdy / x  - x * AccurateMath.sin(y) * f0 / (a * a * a);
-                                Assert.assertEquals(df2dxdy, f.getPartialDerivative(1, 1, 0), AccurateMath.abs(epsilon * df2dxdy));
+                                double df2dz2 = x * (2 * a * (1 - a * cz * JdkMath.sin(z)) * dfdx - x * f0 / a ) / (a * a * a * c4);
+                                Assert.assertEquals(df2dz2, f.getPartialDerivative(0, 0, 2), JdkMath.abs(epsilon * df2dz2));
+                                double df2dxdy = dfdy / x  - x * JdkMath.sin(y) * f0 / (a * a * a);
+                                Assert.assertEquals(df2dxdy, f.getPartialDerivative(1, 1, 0), JdkMath.abs(epsilon * df2dxdy));
                             }
                         }
                     }
@@ -542,7 +542,7 @@
                 double[] gDerivatives = new double[ 1 + maxOrder];
                 gDerivatives[0] = 0.0;
                 for (int k = 1; k <= maxOrder; ++k) {
-                    gDerivatives[k] = AccurateMath.pow(-1.0, k + 1);
+                    gDerivatives[k] = JdkMath.pow(-1.0, k + 1);
                 }
                 DerivativeStructure correctRoot = new DerivativeStructure(1, maxOrder, gDerivatives).rootN(n);
                 Assert.assertEquals(0.0, correctRoot.getValue(), 1.0e-20);
@@ -719,7 +719,7 @@
                 DerivativeStructure dsX = new DerivativeStructure(2, maxOrder, 0, x);
                 for (double y = -1.7; y < 2; y += 0.2) {
                     DerivativeStructure remainder = dsX.remainder(y);
-                    DerivativeStructure ref = dsX.subtract(x - AccurateMath.IEEEremainder(x, y));
+                    DerivativeStructure ref = dsX.subtract(x - JdkMath.IEEEremainder(x, y));
                     DerivativeStructure zero = remainder.subtract(ref);
                     for (int n = 0; n <= maxOrder; ++n) {
                         for (int m = 0; m <= maxOrder; ++m) {
@@ -742,7 +742,7 @@
                 for (double y = -1.7; y < 2; y += 0.2) {
                     DerivativeStructure dsY = new DerivativeStructure(2, maxOrder, 1, y);
                     DerivativeStructure remainder = dsX.remainder(dsY);
-                    DerivativeStructure ref = dsX.subtract(dsY.multiply((x - AccurateMath.IEEEremainder(x, y)) / y));
+                    DerivativeStructure ref = dsX.subtract(dsY.multiply((x - JdkMath.IEEEremainder(x, y)) / y));
                     DerivativeStructure zero = remainder.subtract(ref);
                     for (int n = 0; n <= maxOrder; ++n) {
                         for (int m = 0; m <= maxOrder; ++m) {
@@ -762,7 +762,7 @@
         double[] epsilon = new double[] { 1.0e-16, 1.0e-16, 1.0e-16, 1.0e-16, 1.0e-16 };
         for (int maxOrder = 0; maxOrder < 5; ++maxOrder) {
             for (double x = 0.1; x < 1.2; x += 0.001) {
-                double refExp = AccurateMath.exp(x);
+                double refExp = JdkMath.exp(x);
                 DerivativeStructure exp = new DerivativeStructure(1, maxOrder, 0, x).exp();
                 for (int n = 0; n <= maxOrder; ++n) {
                     Assert.assertEquals(refExp, exp.getPartialDerivative(n), epsilon[n]);
@@ -794,9 +794,9 @@
         for (int maxOrder = 0; maxOrder < 5; ++maxOrder) {
             for (double x = 0.1; x < 1.2; x += 0.001) {
                 DerivativeStructure log = new DerivativeStructure(1, maxOrder, 0, x).log();
-                Assert.assertEquals(AccurateMath.log(x), log.getValue(), epsilon[0]);
+                Assert.assertEquals(JdkMath.log(x), log.getValue(), epsilon[0]);
                 for (int n = 1; n <= maxOrder; ++n) {
-                    double refDer = -Factorial.value(n - 1) / AccurateMath.pow(-x, n);
+                    double refDer = -Factorial.value(n - 1) / JdkMath.pow(-x, n);
                     Assert.assertEquals(refDer, log.getPartialDerivative(n), epsilon[n]);
                 }
             }
@@ -826,7 +826,7 @@
             for (double x = 0.1; x < 1.2; x += 0.001) {
                 DerivativeStructure dsX = new DerivativeStructure(1, maxOrder, 0, x);
                 DerivativeStructure log101 = dsX.log10();
-                DerivativeStructure log102 = dsX.log().divide(AccurateMath.log(10.0));
+                DerivativeStructure log102 = dsX.log().divide(JdkMath.log(10.0));
                 DerivativeStructure zero = log101.subtract(log102);
                 for (int n = 0; n <= maxOrder; ++n) {
                     Assert.assertEquals(0, zero.getPartialDerivative(n), epsilon[n]);
@@ -888,8 +888,8 @@
                 DerivativeStructure dsX = new DerivativeStructure(1, maxOrder, 0, x);
                 DerivativeStructure sin = dsX.sin();
                 DerivativeStructure cos = dsX.cos();
-                double s = AccurateMath.sin(x);
-                double c = AccurateMath.cos(x);
+                double s = JdkMath.sin(x);
+                double c = JdkMath.cos(x);
                 for (int n = 0; n <= maxOrder; ++n) {
                     switch (n % 4) {
                     case 0 :
@@ -987,7 +987,7 @@
                     DerivativeStructure atan2 = DerivativeStructure.atan2(dsY, dsX);
                     DerivativeStructure ref = dsY.divide(dsX).atan();
                     if (x < 0) {
-                        ref = (y < 0) ? ref.subtract(AccurateMath.PI) : ref.add(AccurateMath.PI);
+                        ref = (y < 0) ? ref.subtract(JdkMath.PI) : ref.add(JdkMath.PI);
                     }
                     DerivativeStructure zero = atan2.subtract(ref);
                     for (int n = 0; n <= maxOrder; ++n) {
@@ -1009,23 +1009,23 @@
                 DerivativeStructure.atan2(new DerivativeStructure(2, 2, 1, +0.0),
                                           new DerivativeStructure(2, 2, 1, +0.0));
         Assert.assertEquals(0, pp.getValue(), 1.0e-15);
-        Assert.assertEquals(+1, AccurateMath.copySign(1, pp.getValue()), 1.0e-15);
+        Assert.assertEquals(+1, JdkMath.copySign(1, pp.getValue()), 1.0e-15);
 
         DerivativeStructure pn =
                 DerivativeStructure.atan2(new DerivativeStructure(2, 2, 1, +0.0),
                                           new DerivativeStructure(2, 2, 1, -0.0));
-        Assert.assertEquals(AccurateMath.PI, pn.getValue(), 1.0e-15);
+        Assert.assertEquals(JdkMath.PI, pn.getValue(), 1.0e-15);
 
         DerivativeStructure np =
                 DerivativeStructure.atan2(new DerivativeStructure(2, 2, 1, -0.0),
                                           new DerivativeStructure(2, 2, 1, +0.0));
         Assert.assertEquals(0, np.getValue(), 1.0e-15);
-        Assert.assertEquals(-1, AccurateMath.copySign(1, np.getValue()), 1.0e-15);
+        Assert.assertEquals(-1, JdkMath.copySign(1, np.getValue()), 1.0e-15);
 
         DerivativeStructure nn =
                 DerivativeStructure.atan2(new DerivativeStructure(2, 2, 1, -0.0),
                                           new DerivativeStructure(2, 2, 1, -0.0));
-        Assert.assertEquals(-AccurateMath.PI, nn.getValue(), 1.0e-15);
+        Assert.assertEquals(-JdkMath.PI, nn.getValue(), 1.0e-15);
 
     }
 
@@ -1131,17 +1131,17 @@
                 for (double y = 0.1; y < 1.2; y += 0.1) {
                     DerivativeStructure dsY = new DerivativeStructure(1, maxOrder, 0, y);
                     DerivativeStructure f = dsX.divide(dsY).sqrt();
-                    double f0 = AccurateMath.sqrt(x / y);
-                    Assert.assertEquals(f0, f.getValue(), AccurateMath.abs(epsilon * f0));
+                    double f0 = JdkMath.sqrt(x / y);
+                    Assert.assertEquals(f0, f.getValue(), JdkMath.abs(epsilon * f0));
                     if (f.getOrder() > 0) {
                         double f1 = -x / (2 * y * y * f0);
-                        Assert.assertEquals(f1, f.getPartialDerivative(1), AccurateMath.abs(epsilon * f1));
+                        Assert.assertEquals(f1, f.getPartialDerivative(1), JdkMath.abs(epsilon * f1));
                         if (f.getOrder() > 1) {
                             double f2 = (f0 - x / (4 * y * f0)) / (y * y);
-                            Assert.assertEquals(f2, f.getPartialDerivative(2), AccurateMath.abs(epsilon * f2));
+                            Assert.assertEquals(f2, f.getPartialDerivative(2), JdkMath.abs(epsilon * f2));
                             if (f.getOrder() > 2) {
                                 double f3 = (x / (8 * y * f0) - 2 * f0) / (y * y * y);
-                                Assert.assertEquals(f3, f.getPartialDerivative(3), AccurateMath.abs(epsilon * f3));
+                                Assert.assertEquals(f3, f.getPartialDerivative(3), JdkMath.abs(epsilon * f3));
                             }
                         }
                     }
@@ -1184,8 +1184,8 @@
             double maxError = 0;
             for (double dx = -0.05; dx < 0.05; dx += 0.001) {
                 for (double dy = -0.05; dy < 0.05; dy += 0.001) {
-                    double ref = AccurateMath.atan2(y0 + dy, x0 + dx);
-                    maxError = AccurateMath.max(maxError, AccurateMath.abs(ref - atan2.taylor(dx, dy)));
+                    double ref = JdkMath.atan2(y0 + dy, x0 + dx);
+                    maxError = JdkMath.max(maxError, JdkMath.abs(ref - atan2.taylor(dx, dy)));
                 }
             }
             Assert.assertEquals(0.0, expected[maxOrder] - maxError, 0.01 * expected[maxOrder]);
@@ -1290,10 +1290,10 @@
         for (int maxOrder = 0; maxOrder < 6; ++maxOrder) {
             for (double x = 0.1; x < 1.2; x += 0.001) {
                 DerivativeStructure dsX = new DerivativeStructure(1, maxOrder, 0, x);
-                Assert.assertEquals(AccurateMath.toDegrees(x), dsX.toDegrees().getValue(), epsilon);
+                Assert.assertEquals(JdkMath.toDegrees(x), dsX.toDegrees().getValue(), epsilon);
                 for (int n = 1; n <= maxOrder; ++n) {
                     if (n == 1) {
-                        Assert.assertEquals(180 / AccurateMath.PI, dsX.toDegrees().getPartialDerivative(1), epsilon);
+                        Assert.assertEquals(180 / JdkMath.PI, dsX.toDegrees().getPartialDerivative(1), epsilon);
                     } else {
                         Assert.assertEquals(0.0, dsX.toDegrees().getPartialDerivative(n), epsilon);
                     }
@@ -1308,10 +1308,10 @@
         for (int maxOrder = 0; maxOrder < 6; ++maxOrder) {
             for (double x = 0.1; x < 1.2; x += 0.001) {
                 DerivativeStructure dsX = new DerivativeStructure(1, maxOrder, 0, x);
-                Assert.assertEquals(AccurateMath.toRadians(x), dsX.toRadians().getValue(), epsilon);
+                Assert.assertEquals(JdkMath.toRadians(x), dsX.toRadians().getValue(), epsilon);
                 for (int n = 1; n <= maxOrder; ++n) {
                     if (n == 1) {
-                        Assert.assertEquals(AccurateMath.PI / 180, dsX.toRadians().getPartialDerivative(1), epsilon);
+                        Assert.assertEquals(JdkMath.PI / 180, dsX.toRadians().getPartialDerivative(1), epsilon);
                     } else {
                         Assert.assertEquals(0.0, dsX.toRadians().getPartialDerivative(n), epsilon);
                     }
@@ -1385,8 +1385,8 @@
     @Test
     public void testOneParameterConstructor() {
         double x = 1.2;
-        double cos = AccurateMath.cos(x);
-        double sin = AccurateMath.sin(x);
+        double cos = JdkMath.cos(x);
+        double sin = JdkMath.sin(x);
         DerivativeStructure yRef = new DerivativeStructure(1, 4, 0, x).cos();
         try {
             new DerivativeStructure(1, 4, 0.0, 0.0);
@@ -1494,29 +1494,29 @@
             DerivativeStructure lin = u[0].linearCombination(u[0], v[0], u[1], v[1]);
             double ref = u[0].getValue() * v[0].getValue() +
                          u[1].getValue() * v[1].getValue();
-            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * AccurateMath.abs(ref));
-            Assert.assertEquals(v[0].getValue(), lin.getPartialDerivative(1, 0, 0, 0), 1.0e-15 * AccurateMath.abs(v[0].getValue()));
-            Assert.assertEquals(v[1].getValue(), lin.getPartialDerivative(0, 1, 0, 0), 1.0e-15 * AccurateMath.abs(v[1].getValue()));
+            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * JdkMath.abs(ref));
+            Assert.assertEquals(v[0].getValue(), lin.getPartialDerivative(1, 0, 0, 0), 1.0e-15 * JdkMath.abs(v[0].getValue()));
+            Assert.assertEquals(v[1].getValue(), lin.getPartialDerivative(0, 1, 0, 0), 1.0e-15 * JdkMath.abs(v[1].getValue()));
 
             lin = u[0].linearCombination(u[0], v[0], u[1], v[1], u[2], v[2]);
             ref = u[0].getValue() * v[0].getValue() +
                   u[1].getValue() * v[1].getValue() +
                   u[2].getValue() * v[2].getValue();
-            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * AccurateMath.abs(ref));
-            Assert.assertEquals(v[0].getValue(), lin.getPartialDerivative(1, 0, 0, 0), 1.0e-15 * AccurateMath.abs(v[0].getValue()));
-            Assert.assertEquals(v[1].getValue(), lin.getPartialDerivative(0, 1, 0, 0), 1.0e-15 * AccurateMath.abs(v[1].getValue()));
-            Assert.assertEquals(v[2].getValue(), lin.getPartialDerivative(0, 0, 1, 0), 1.0e-15 * AccurateMath.abs(v[2].getValue()));
+            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * JdkMath.abs(ref));
+            Assert.assertEquals(v[0].getValue(), lin.getPartialDerivative(1, 0, 0, 0), 1.0e-15 * JdkMath.abs(v[0].getValue()));
+            Assert.assertEquals(v[1].getValue(), lin.getPartialDerivative(0, 1, 0, 0), 1.0e-15 * JdkMath.abs(v[1].getValue()));
+            Assert.assertEquals(v[2].getValue(), lin.getPartialDerivative(0, 0, 1, 0), 1.0e-15 * JdkMath.abs(v[2].getValue()));
 
             lin = u[0].linearCombination(u[0], v[0], u[1], v[1], u[2], v[2], u[3], v[3]);
             ref = u[0].getValue() * v[0].getValue() +
                   u[1].getValue() * v[1].getValue() +
                   u[2].getValue() * v[2].getValue() +
                   u[3].getValue() * v[3].getValue();
-            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * AccurateMath.abs(ref));
-            Assert.assertEquals(v[0].getValue(), lin.getPartialDerivative(1, 0, 0, 0), 1.0e-15 * AccurateMath.abs(v[0].getValue()));
-            Assert.assertEquals(v[1].getValue(), lin.getPartialDerivative(0, 1, 0, 0), 1.0e-15 * AccurateMath.abs(v[1].getValue()));
-            Assert.assertEquals(v[2].getValue(), lin.getPartialDerivative(0, 0, 1, 0), 1.0e-15 * AccurateMath.abs(v[2].getValue()));
-            Assert.assertEquals(v[3].getValue(), lin.getPartialDerivative(0, 0, 0, 1), 1.0e-15 * AccurateMath.abs(v[3].getValue()));
+            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * JdkMath.abs(ref));
+            Assert.assertEquals(v[0].getValue(), lin.getPartialDerivative(1, 0, 0, 0), 1.0e-15 * JdkMath.abs(v[0].getValue()));
+            Assert.assertEquals(v[1].getValue(), lin.getPartialDerivative(0, 1, 0, 0), 1.0e-15 * JdkMath.abs(v[1].getValue()));
+            Assert.assertEquals(v[2].getValue(), lin.getPartialDerivative(0, 0, 1, 0), 1.0e-15 * JdkMath.abs(v[2].getValue()));
+            Assert.assertEquals(v[3].getValue(), lin.getPartialDerivative(0, 0, 0, 1), 1.0e-15 * JdkMath.abs(v[3].getValue()));
 
         }
     }
@@ -1538,29 +1538,29 @@
             DerivativeStructure lin = v[0].linearCombination(u[0], v[0], u[1], v[1]);
             double ref = u[0] * v[0].getValue() +
                          u[1] * v[1].getValue();
-            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * AccurateMath.abs(ref));
-            Assert.assertEquals(u[0], lin.getPartialDerivative(1, 0, 0, 0), 1.0e-15 * AccurateMath.abs(v[0].getValue()));
-            Assert.assertEquals(u[1], lin.getPartialDerivative(0, 1, 0, 0), 1.0e-15 * AccurateMath.abs(v[1].getValue()));
+            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * JdkMath.abs(ref));
+            Assert.assertEquals(u[0], lin.getPartialDerivative(1, 0, 0, 0), 1.0e-15 * JdkMath.abs(v[0].getValue()));
+            Assert.assertEquals(u[1], lin.getPartialDerivative(0, 1, 0, 0), 1.0e-15 * JdkMath.abs(v[1].getValue()));
 
             lin = v[0].linearCombination(u[0], v[0], u[1], v[1], u[2], v[2]);
             ref = u[0] * v[0].getValue() +
                   u[1] * v[1].getValue() +
                   u[2] * v[2].getValue();
-            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * AccurateMath.abs(ref));
-            Assert.assertEquals(u[0], lin.getPartialDerivative(1, 0, 0, 0), 1.0e-15 * AccurateMath.abs(v[0].getValue()));
-            Assert.assertEquals(u[1], lin.getPartialDerivative(0, 1, 0, 0), 1.0e-15 * AccurateMath.abs(v[1].getValue()));
-            Assert.assertEquals(u[2], lin.getPartialDerivative(0, 0, 1, 0), 1.0e-15 * AccurateMath.abs(v[2].getValue()));
+            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * JdkMath.abs(ref));
+            Assert.assertEquals(u[0], lin.getPartialDerivative(1, 0, 0, 0), 1.0e-15 * JdkMath.abs(v[0].getValue()));
+            Assert.assertEquals(u[1], lin.getPartialDerivative(0, 1, 0, 0), 1.0e-15 * JdkMath.abs(v[1].getValue()));
+            Assert.assertEquals(u[2], lin.getPartialDerivative(0, 0, 1, 0), 1.0e-15 * JdkMath.abs(v[2].getValue()));
 
             lin = v[0].linearCombination(u[0], v[0], u[1], v[1], u[2], v[2], u[3], v[3]);
             ref = u[0] * v[0].getValue() +
                   u[1] * v[1].getValue() +
                   u[2] * v[2].getValue() +
                   u[3] * v[3].getValue();
-            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * AccurateMath.abs(ref));
-            Assert.assertEquals(u[0], lin.getPartialDerivative(1, 0, 0, 0), 1.0e-15 * AccurateMath.abs(v[0].getValue()));
-            Assert.assertEquals(u[1], lin.getPartialDerivative(0, 1, 0, 0), 1.0e-15 * AccurateMath.abs(v[1].getValue()));
-            Assert.assertEquals(u[2], lin.getPartialDerivative(0, 0, 1, 0), 1.0e-15 * AccurateMath.abs(v[2].getValue()));
-            Assert.assertEquals(u[3], lin.getPartialDerivative(0, 0, 0, 1), 1.0e-15 * AccurateMath.abs(v[3].getValue()));
+            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * JdkMath.abs(ref));
+            Assert.assertEquals(u[0], lin.getPartialDerivative(1, 0, 0, 0), 1.0e-15 * JdkMath.abs(v[0].getValue()));
+            Assert.assertEquals(u[1], lin.getPartialDerivative(0, 1, 0, 0), 1.0e-15 * JdkMath.abs(v[1].getValue()));
+            Assert.assertEquals(u[2], lin.getPartialDerivative(0, 0, 1, 0), 1.0e-15 * JdkMath.abs(v[2].getValue()));
+            Assert.assertEquals(u[3], lin.getPartialDerivative(0, 0, 0, 1), 1.0e-15 * JdkMath.abs(v[3].getValue()));
 
         }
     }
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/FiniteDifferencesDifferentiatorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/FiniteDifferencesDifferentiatorTest.java
index 99def80..8e42d4c 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/FiniteDifferencesDifferentiatorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/FiniteDifferencesDifferentiatorTest.java
@@ -28,7 +28,7 @@
 import org.apache.commons.math4.legacy.exception.NotPositiveException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -112,8 +112,8 @@
             DerivativeStructure y    = f.value(dsX);
             Assert.assertEquals(f.value(dsX.getValue()), f.value(dsX).getValue(), 1.0e-15);
             for (int order = 0; order <= yRef.getOrder(); ++order) {
-                maxError[order] = AccurateMath.max(maxError[order],
-                                        AccurateMath.abs(yRef.getPartialDerivative(order) -
+                maxError[order] = JdkMath.max(maxError[order],
+                                        JdkMath.abs(yRef.getPartialDerivative(order) -
                                                      y.getPartialDerivative(order)));
             }
         }
@@ -137,11 +137,11 @@
             DerivativeStructure yGood = goodStep.value(dsX);
             DerivativeStructure yBad  = badStep.value(dsX);
             for (int order = 0; order <= 6; ++order) {
-                maxErrorGood[order] = AccurateMath.max(maxErrorGood[order],
-                                                   AccurateMath.abs(yRef.getPartialDerivative(order) -
+                maxErrorGood[order] = JdkMath.max(maxErrorGood[order],
+                                                   JdkMath.abs(yRef.getPartialDerivative(order) -
                                                                 yGood.getPartialDerivative(order)));
-                maxErrorBad[order]  = AccurateMath.max(maxErrorBad[order],
-                                                   AccurateMath.abs(yRef.getPartialDerivative(order) -
+                maxErrorBad[order]  = JdkMath.max(maxErrorBad[order],
+                                                   JdkMath.abs(yRef.getPartialDerivative(order) -
                                                                 yBad.getPartialDerivative(order)));
             }
         }
@@ -276,17 +276,17 @@
         UnivariateDifferentiableFunction sqrt = differentiator.differentiate(new UnivariateFunction() {
             @Override
             public double value(double x) {
-                return AccurateMath.sqrt(x);
+                return JdkMath.sqrt(x);
             }
         });
 
         // we are able to compute derivative near 0, but the accuracy is much poorer there
         DerivativeStructure t001 = new DerivativeStructure(1, 1, 0, 0.01);
-        Assert.assertEquals(0.5 / AccurateMath.sqrt(t001.getValue()), sqrt.value(t001).getPartialDerivative(1), 1.6);
+        Assert.assertEquals(0.5 / JdkMath.sqrt(t001.getValue()), sqrt.value(t001).getPartialDerivative(1), 1.6);
         DerivativeStructure t01 = new DerivativeStructure(1, 1, 0, 0.1);
-        Assert.assertEquals(0.5 / AccurateMath.sqrt(t01.getValue()), sqrt.value(t01).getPartialDerivative(1), 7.0e-3);
+        Assert.assertEquals(0.5 / JdkMath.sqrt(t01.getValue()), sqrt.value(t01).getPartialDerivative(1), 7.0e-3);
         DerivativeStructure t03 = new DerivativeStructure(1, 1, 0, 0.3);
-        Assert.assertEquals(0.5 / AccurateMath.sqrt(t03.getValue()), sqrt.value(t03).getPartialDerivative(1), 2.1e-7);
+        Assert.assertEquals(0.5 / JdkMath.sqrt(t03.getValue()), sqrt.value(t03).getPartialDerivative(1), 2.1e-7);
 
     }
 
@@ -300,7 +300,7 @@
 
             @Override
             public double[] value(double x) {
-                return new double[] { AccurateMath.cos(x), AccurateMath.sin(x) };
+                return new double[] { JdkMath.cos(x), JdkMath.sin(x) };
             }
 
         });
@@ -308,8 +308,8 @@
         for (double x = -10; x < 10; x += 0.1) {
             DerivativeStructure dsX = new DerivativeStructure(1, 2, 0, x);
             DerivativeStructure[] y = f.value(dsX);
-            double cos = AccurateMath.cos(x);
-            double sin = AccurateMath.sin(x);
+            double cos = JdkMath.cos(x);
+            double sin = JdkMath.sin(x);
             double[] f1 = f.value(dsX.getValue());
             DerivativeStructure[] f2 = f.value(dsX);
             Assert.assertEquals(f1.length, f2.length);
@@ -337,8 +337,8 @@
             @Override
             public double[][] value(double x) {
                 return new double[][] {
-                    { AccurateMath.cos(x),  AccurateMath.sin(x)  },
-                    { AccurateMath.cosh(x), AccurateMath.sinh(x) }
+                    { JdkMath.cos(x),  JdkMath.sin(x)  },
+                    { JdkMath.cosh(x), JdkMath.sinh(x) }
                 };
             }
 
@@ -347,10 +347,10 @@
         for (double x = -1; x < 1; x += 0.02) {
             DerivativeStructure dsX = new DerivativeStructure(1, 2, 0, x);
             DerivativeStructure[][] y = f.value(dsX);
-            double cos = AccurateMath.cos(x);
-            double sin = AccurateMath.sin(x);
-            double cosh = AccurateMath.cosh(x);
-            double sinh = AccurateMath.sinh(x);
+            double cos = JdkMath.cos(x);
+            double sin = JdkMath.sin(x);
+            double cosh = JdkMath.cosh(x);
+            double sinh = JdkMath.sinh(x);
             double[][] f1 = f.value(dsX.getValue());
             DerivativeStructure[][] f2 = f.value(dsX);
             Assert.assertEquals(f1.length, f2.length);
@@ -397,8 +397,8 @@
                for (int xOrder = 0; xOrder <= sRef.getOrder(); ++xOrder) {
                    for (int yOrder = 0; yOrder <= sRef.getOrder(); ++yOrder) {
                        if (xOrder + yOrder <= sRef.getOrder()) {
-                           maxError[xOrder +yOrder] = AccurateMath.max(maxError[xOrder + yOrder],
-                                                                    AccurateMath.abs(sRef.getPartialDerivative(xOrder, yOrder) -
+                           maxError[xOrder +yOrder] = JdkMath.max(maxError[xOrder + yOrder],
+                                                                    JdkMath.abs(sRef.getPartialDerivative(xOrder, yOrder) -
                                                                                  s.getPartialDerivative(xOrder, yOrder)));
                        }
                    }
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/GradientFunctionTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/GradientFunctionTest.java
index d0cee3a..b518a8d 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/GradientFunctionTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/GradientFunctionTest.java
@@ -20,7 +20,7 @@
 import org.apache.commons.math4.legacy.TestUtils;
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
 import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.junit.Test;
 
 
@@ -63,7 +63,7 @@
             for (double x : point) {
                 d2 += x * x;
             }
-            return AccurateMath.sqrt(d2);
+            return JdkMath.sqrt(d2);
         }
 
         @Override
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/JacobianFunctionTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/JacobianFunctionTest.java
index 39b9ff5..696a9eb 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/JacobianFunctionTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/JacobianFunctionTest.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.analysis.differentiation;
 
 import org.apache.commons.math4.legacy.TestUtils;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -56,10 +56,10 @@
 
         @Override
         public double[] value(double[] point) {
-            final double cLat = AccurateMath.cos(point[0]);
-            final double sLat = AccurateMath.sin(point[0]);
-            final double cLon = AccurateMath.cos(point[1]);
-            final double sLon = AccurateMath.sin(point[1]);
+            final double cLat = JdkMath.cos(point[0]);
+            final double sLat = JdkMath.sin(point[0]);
+            final double cLon = JdkMath.cos(point[1]);
+            final double sLon = JdkMath.sin(point[1]);
             return new double[] {
                 radius * cLon * cLat,
                 radius * sLon * cLat,
@@ -81,10 +81,10 @@
         }
 
         public double[][] jacobian(double[] point) {
-            final double cLat = AccurateMath.cos(point[0]);
-            final double sLat = AccurateMath.sin(point[0]);
-            final double cLon = AccurateMath.cos(point[1]);
-            final double sLon = AccurateMath.sin(point[1]);
+            final double cLat = JdkMath.cos(point[0]);
+            final double sLat = JdkMath.sin(point[0]);
+            final double cLon = JdkMath.cos(point[1]);
+            final double sLon = JdkMath.sin(point[1]);
             return new double[][] {
                 { -radius * cLon * sLat, -radius * sLon * cLat },
                 { -radius * sLon * sLat,  radius * cLon * cLat },
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/SparseGradientTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/SparseGradientTest.java
index 7dee83f..ada18e5 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/SparseGradientTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/differentiation/SparseGradientTest.java
@@ -24,7 +24,7 @@
 import org.apache.commons.math4.legacy.analysis.polynomials.PolynomialFunction;
 import org.apache.commons.rng.UniformRandomProvider;
 import org.apache.commons.rng.simple.RandomSource;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -196,7 +196,7 @@
             SparseGradient r = SparseGradient.createVariable(0, x).reciprocal();
             Assert.assertEquals(1 / x, r.getValue(), 1.0e-15);
             final double expected = -1 / (x * x);
-            Assert.assertEquals(expected, r.getDerivative(0), 1.0e-15 * AccurateMath.abs(expected));
+            Assert.assertEquals(expected, r.getDerivative(0), 1.0e-15 * JdkMath.abs(expected));
         }
     }
 
@@ -270,7 +270,7 @@
             Assert.assertTrue(Double.isNaN(zeroNeg.getDerivative(0)));
             SparseGradient posNeg = SparseGradient.pow(2.0, SparseGradient.createVariable(0, -2.0));
             Assert.assertEquals(1.0 / 4.0, posNeg.getValue(), 1.0e-15);
-            Assert.assertEquals(AccurateMath.log(2.0) / 4.0, posNeg.getDerivative(0), 1.0e-15);
+            Assert.assertEquals(JdkMath.log(2.0) / 4.0, posNeg.getDerivative(0), 1.0e-15);
 
             // very special case: a = 0 and power = 0
             SparseGradient zeroZero = SparseGradient.pow(0.0, SparseGradient.createVariable(0, 0.0));
@@ -301,12 +301,12 @@
                                                   5, sgX.multiply(sgY),
                                                  -2, sgZ,
                                                  1, sgZ.linearCombination(8, sgZ.multiply(sgX), -1, sgY).pow(3));
-                    double f = x + 5 * x * y - 2 * z + AccurateMath.pow(8 * z * x - y, 3);
-                    Assert.assertEquals(f, sg.getValue(), AccurateMath.abs(epsilon * f));
+                    double f = x + 5 * x * y - 2 * z + JdkMath.pow(8 * z * x - y, 3);
+                    Assert.assertEquals(f, sg.getValue(), JdkMath.abs(epsilon * f));
 
                     // df/dx = 1 + 5 y + 24 (8 z x - y)^2 z
-                    double dfdx = 1 + 5 * y + 24 * z * AccurateMath.pow(8 * z * x - y, 2);
-                    Assert.assertEquals(dfdx, sg.getDerivative(0), AccurateMath.abs(epsilon * dfdx));
+                    double dfdx = 1 + 5 * y + 24 * z * JdkMath.pow(8 * z * x - y, 2);
+                    Assert.assertEquals(dfdx, sg.getDerivative(0), JdkMath.abs(epsilon * dfdx));
 
                 }
 
@@ -322,10 +322,10 @@
             for (double y = 0.1; y < 1.2; y += 0.1) {
                 SparseGradient sgY = SparseGradient.createConstant(y);
                 SparseGradient f = sgX.divide(sgY).sqrt();
-                double f0 = AccurateMath.sqrt(x / y);
-                Assert.assertEquals(f0, f.getValue(), AccurateMath.abs(epsilon * f0));
-                double f1 = 1 / (2 * AccurateMath.sqrt(x * y));
-                Assert.assertEquals(f1, f.getDerivative(0), AccurateMath.abs(epsilon * f1));
+                double f0 = JdkMath.sqrt(x / y);
+                Assert.assertEquals(f0, f.getValue(), JdkMath.abs(epsilon * f0));
+                double f1 = 1 / (2 * JdkMath.sqrt(x * y));
+                Assert.assertEquals(f1, f.getDerivative(0), JdkMath.abs(epsilon * f1));
             }
         }
     }
@@ -340,17 +340,17 @@
                     for (double z = 0.1; z < 1.2; z += 0.1) {
                         SparseGradient sgZ = SparseGradient.createVariable(2, z);
                         SparseGradient f = sgX.divide(sgY.cos().add(sgZ.tan())).sin();
-                        double a = AccurateMath.cos(y) + AccurateMath.tan(z);
-                        double f0 = AccurateMath.sin(x / a);
-                        Assert.assertEquals(f0, f.getValue(), AccurateMath.abs(epsilon * f0));
-                        double dfdx = AccurateMath.cos(x / a) / a;
-                        Assert.assertEquals(dfdx, f.getDerivative(0), AccurateMath.abs(epsilon * dfdx));
-                        double dfdy =  x * AccurateMath.sin(y) * dfdx / a;
-                        Assert.assertEquals(dfdy, f.getDerivative(1), AccurateMath.abs(epsilon * dfdy));
-                        double cz = AccurateMath.cos(z);
+                        double a = JdkMath.cos(y) + JdkMath.tan(z);
+                        double f0 = JdkMath.sin(x / a);
+                        Assert.assertEquals(f0, f.getValue(), JdkMath.abs(epsilon * f0));
+                        double dfdx = JdkMath.cos(x / a) / a;
+                        Assert.assertEquals(dfdx, f.getDerivative(0), JdkMath.abs(epsilon * dfdx));
+                        double dfdy =  x * JdkMath.sin(y) * dfdx / a;
+                        Assert.assertEquals(dfdy, f.getDerivative(1), JdkMath.abs(epsilon * dfdy));
+                        double cz = JdkMath.cos(z);
                         double cz2 = cz * cz;
                         double dfdz = -x * dfdx / (a * cz2);
-                        Assert.assertEquals(dfdz, f.getDerivative(2), AccurateMath.abs(epsilon * dfdz));
+                        Assert.assertEquals(dfdz, f.getDerivative(2), JdkMath.abs(epsilon * dfdz));
                     }
                 }
             }
@@ -499,7 +499,7 @@
             SparseGradient sgX = SparseGradient.createVariable(0, x);
             for (double y = -1.7; y < 2; y += 0.2) {
                 SparseGradient remainder = sgX.remainder(y);
-                SparseGradient ref = sgX.subtract(x - AccurateMath.IEEEremainder(x, y));
+                SparseGradient ref = sgX.subtract(x - JdkMath.IEEEremainder(x, y));
                 SparseGradient zero = remainder.subtract(ref);
                 checkF0F1(zero, 0.0, 0.0, 0.0);
             }
@@ -513,7 +513,7 @@
             for (double y = -1.7; y < 2; y += 0.2) {
                 SparseGradient sgY = SparseGradient.createVariable(1, y);
                 SparseGradient remainder = sgX.remainder(sgY);
-                SparseGradient ref = sgX.subtract(sgY.multiply((x - AccurateMath.IEEEremainder(x, y)) / y));
+                SparseGradient ref = sgX.subtract(sgY.multiply((x - JdkMath.IEEEremainder(x, y)) / y));
                 SparseGradient zero = remainder.subtract(ref);
                 checkF0F1(zero, 0.0, 0.0, 0.0);
             }
@@ -524,7 +524,7 @@
     @Test
     public void testExp() {
         for (double x = 0.1; x < 1.2; x += 0.001) {
-            double refExp = AccurateMath.exp(x);
+            double refExp = JdkMath.exp(x);
             checkF0F1(SparseGradient.createVariable(0, x).exp(), refExp, refExp);
         }
     }
@@ -544,7 +544,7 @@
     @Test
     public void testLog() {
         for (double x = 0.1; x < 1.2; x += 0.001) {
-            checkF0F1(SparseGradient.createVariable(0, x).log(), AccurateMath.log(x), 1.0 / x);
+            checkF0F1(SparseGradient.createVariable(0, x).log(), JdkMath.log(x), 1.0 / x);
         }
     }
 
@@ -564,7 +564,7 @@
         for (double x = 0.1; x < 1.2; x += 0.001) {
             SparseGradient sgX = SparseGradient.createVariable(0, x);
             SparseGradient log101 = sgX.log10();
-            SparseGradient log102 = sgX.log().divide(AccurateMath.log(10.0));
+            SparseGradient log102 = sgX.log().divide(JdkMath.log(10.0));
             SparseGradient zero = log101.subtract(log102);
             checkF0F1(zero, 0.0, 0.0);
         }
@@ -606,8 +606,8 @@
             SparseGradient sgX = SparseGradient.createVariable(0, x);
             SparseGradient sin = sgX.sin();
             SparseGradient cos = sgX.cos();
-            double s = AccurateMath.sin(x);
-            double c = AccurateMath.cos(x);
+            double s = JdkMath.sin(x);
+            double c = JdkMath.cos(x);
             checkF0F1(sin, s, c);
             checkF0F1(cos, c, -s);
         }
@@ -664,7 +664,7 @@
                 SparseGradient atan2 = SparseGradient.atan2(sgY, sgX);
                 SparseGradient ref = sgY.divide(sgX).atan();
                 if (x < 0) {
-                    ref = (y < 0) ? ref.subtract(AccurateMath.PI) : ref.add(AccurateMath.PI);
+                    ref = (y < 0) ? ref.subtract(JdkMath.PI) : ref.add(JdkMath.PI);
                 }
                 SparseGradient zero = atan2.subtract(ref);
                 checkF0F1(zero, 0.0, 0.0);
@@ -679,23 +679,23 @@
                 SparseGradient.atan2(SparseGradient.createVariable(1, +0.0),
                                           SparseGradient.createVariable(1, +0.0));
         Assert.assertEquals(0, pp.getValue(), 1.0e-15);
-        Assert.assertEquals(+1, AccurateMath.copySign(1, pp.getValue()), 1.0e-15);
+        Assert.assertEquals(+1, JdkMath.copySign(1, pp.getValue()), 1.0e-15);
 
         SparseGradient pn =
                 SparseGradient.atan2(SparseGradient.createVariable(1, +0.0),
                                           SparseGradient.createVariable(1, -0.0));
-        Assert.assertEquals(AccurateMath.PI, pn.getValue(), 1.0e-15);
+        Assert.assertEquals(JdkMath.PI, pn.getValue(), 1.0e-15);
 
         SparseGradient np =
                 SparseGradient.atan2(SparseGradient.createVariable(1, -0.0),
                                           SparseGradient.createVariable(1, +0.0));
         Assert.assertEquals(0, np.getValue(), 1.0e-15);
-        Assert.assertEquals(-1, AccurateMath.copySign(1, np.getValue()), 1.0e-15);
+        Assert.assertEquals(-1, JdkMath.copySign(1, np.getValue()), 1.0e-15);
 
         SparseGradient nn =
                 SparseGradient.atan2(SparseGradient.createVariable(1, -0.0),
                                           SparseGradient.createVariable(1, -0.0));
-        Assert.assertEquals(-AccurateMath.PI, nn.getValue(), 1.0e-15);
+        Assert.assertEquals(-JdkMath.PI, nn.getValue(), 1.0e-15);
 
     }
 
@@ -769,7 +769,7 @@
             for (double y = 0.1; y < 1.2; y += 0.1) {
                 SparseGradient sgY = SparseGradient.createVariable(0, y);
                 SparseGradient f = sgX.divide(sgY).sqrt();
-                double f0 = AccurateMath.sqrt(x / y);
+                double f0 = JdkMath.sqrt(x / y);
                 double f1 = -x / (2 * y * y * f0);
                 checkF0F1(f, f0, f1);
             }
@@ -808,8 +808,8 @@
             double maxError = 0;
             for (double dx = -0.05; dx < 0.05; dx += 0.001) {
                 for (double dy = -0.05; dy < 0.05; dy += 0.001) {
-                    double ref = AccurateMath.atan2(y0 + dy, x0 + dx);
-                    maxError = AccurateMath.max(maxError, AccurateMath.abs(ref - atan2.taylor(dx, dy)));
+                    double ref = JdkMath.atan2(y0 + dy, x0 + dx);
+                    maxError = JdkMath.max(maxError, JdkMath.abs(ref - atan2.taylor(dx, dy)));
                 }
             }
             double expectedError = 0.0241;
@@ -914,8 +914,8 @@
         for (int maxOrder = 0; maxOrder < 6; ++maxOrder) {
             for (double x = 0.1; x < 1.2; x += 0.001) {
                 SparseGradient sgX = SparseGradient.createVariable(0, x);
-                Assert.assertEquals(AccurateMath.toDegrees(x), sgX.toDegrees().getValue(), epsilon);
-                Assert.assertEquals(180 / AccurateMath.PI, sgX.toDegrees().getDerivative(0), epsilon);
+                Assert.assertEquals(JdkMath.toDegrees(x), sgX.toDegrees().getValue(), epsilon);
+                Assert.assertEquals(180 / JdkMath.PI, sgX.toDegrees().getDerivative(0), epsilon);
             }
         }
     }
@@ -926,8 +926,8 @@
         for (int maxOrder = 0; maxOrder < 6; ++maxOrder) {
             for (double x = 0.1; x < 1.2; x += 0.001) {
                 SparseGradient sgX = SparseGradient.createVariable(0, x);
-                Assert.assertEquals(AccurateMath.toRadians(x), sgX.toRadians().getValue(), epsilon);
-                Assert.assertEquals(AccurateMath.PI / 180, sgX.toRadians().getDerivative(0), epsilon);
+                Assert.assertEquals(JdkMath.toRadians(x), sgX.toRadians().getValue(), epsilon);
+                Assert.assertEquals(JdkMath.PI / 180, sgX.toRadians().getDerivative(0), epsilon);
             }
         }
     }
@@ -1036,29 +1036,29 @@
             SparseGradient lin = u[0].linearCombination(u[0], v[0], u[1], v[1]);
             double ref = u[0].getValue() * v[0].getValue() +
                          u[1].getValue() * v[1].getValue();
-            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * AccurateMath.abs(ref));
-            Assert.assertEquals(v[0].getValue(), lin.getDerivative(0), 1.0e-15 * AccurateMath.abs(v[0].getValue()));
-            Assert.assertEquals(v[1].getValue(), lin.getDerivative(1), 1.0e-15 * AccurateMath.abs(v[1].getValue()));
+            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * JdkMath.abs(ref));
+            Assert.assertEquals(v[0].getValue(), lin.getDerivative(0), 1.0e-15 * JdkMath.abs(v[0].getValue()));
+            Assert.assertEquals(v[1].getValue(), lin.getDerivative(1), 1.0e-15 * JdkMath.abs(v[1].getValue()));
 
             lin = u[0].linearCombination(u[0], v[0], u[1], v[1], u[2], v[2]);
             ref = u[0].getValue() * v[0].getValue() +
                   u[1].getValue() * v[1].getValue() +
                   u[2].getValue() * v[2].getValue();
-            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * AccurateMath.abs(ref));
-            Assert.assertEquals(v[0].getValue(), lin.getDerivative(0), 1.0e-15 * AccurateMath.abs(v[0].getValue()));
-            Assert.assertEquals(v[1].getValue(), lin.getDerivative(1), 1.0e-15 * AccurateMath.abs(v[1].getValue()));
-            Assert.assertEquals(v[2].getValue(), lin.getDerivative(2), 1.0e-15 * AccurateMath.abs(v[2].getValue()));
+            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * JdkMath.abs(ref));
+            Assert.assertEquals(v[0].getValue(), lin.getDerivative(0), 1.0e-15 * JdkMath.abs(v[0].getValue()));
+            Assert.assertEquals(v[1].getValue(), lin.getDerivative(1), 1.0e-15 * JdkMath.abs(v[1].getValue()));
+            Assert.assertEquals(v[2].getValue(), lin.getDerivative(2), 1.0e-15 * JdkMath.abs(v[2].getValue()));
 
             lin = u[0].linearCombination(u[0], v[0], u[1], v[1], u[2], v[2], u[3], v[3]);
             ref = u[0].getValue() * v[0].getValue() +
                   u[1].getValue() * v[1].getValue() +
                   u[2].getValue() * v[2].getValue() +
                   u[3].getValue() * v[3].getValue();
-            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * AccurateMath.abs(ref));
-            Assert.assertEquals(v[0].getValue(), lin.getDerivative(0), 1.0e-15 * AccurateMath.abs(v[0].getValue()));
-            Assert.assertEquals(v[1].getValue(), lin.getDerivative(1), 1.0e-15 * AccurateMath.abs(v[1].getValue()));
-            Assert.assertEquals(v[2].getValue(), lin.getDerivative(2), 1.0e-15 * AccurateMath.abs(v[2].getValue()));
-            Assert.assertEquals(v[3].getValue(), lin.getDerivative(3), 1.0e-15 * AccurateMath.abs(v[3].getValue()));
+            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * JdkMath.abs(ref));
+            Assert.assertEquals(v[0].getValue(), lin.getDerivative(0), 1.0e-15 * JdkMath.abs(v[0].getValue()));
+            Assert.assertEquals(v[1].getValue(), lin.getDerivative(1), 1.0e-15 * JdkMath.abs(v[1].getValue()));
+            Assert.assertEquals(v[2].getValue(), lin.getDerivative(2), 1.0e-15 * JdkMath.abs(v[2].getValue()));
+            Assert.assertEquals(v[3].getValue(), lin.getDerivative(3), 1.0e-15 * JdkMath.abs(v[3].getValue()));
 
         }
     }
@@ -1080,29 +1080,29 @@
             SparseGradient lin = v[0].linearCombination(u[0], v[0], u[1], v[1]);
             double ref = u[0] * v[0].getValue() +
                          u[1] * v[1].getValue();
-            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * AccurateMath.abs(ref));
-            Assert.assertEquals(u[0], lin.getDerivative(0), 1.0e-15 * AccurateMath.abs(v[0].getValue()));
-            Assert.assertEquals(u[1], lin.getDerivative(1), 1.0e-15 * AccurateMath.abs(v[1].getValue()));
+            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * JdkMath.abs(ref));
+            Assert.assertEquals(u[0], lin.getDerivative(0), 1.0e-15 * JdkMath.abs(v[0].getValue()));
+            Assert.assertEquals(u[1], lin.getDerivative(1), 1.0e-15 * JdkMath.abs(v[1].getValue()));
 
             lin = v[0].linearCombination(u[0], v[0], u[1], v[1], u[2], v[2]);
             ref = u[0] * v[0].getValue() +
                   u[1] * v[1].getValue() +
                   u[2] * v[2].getValue();
-            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * AccurateMath.abs(ref));
-            Assert.assertEquals(u[0], lin.getDerivative(0), 1.0e-15 * AccurateMath.abs(v[0].getValue()));
-            Assert.assertEquals(u[1], lin.getDerivative(1), 1.0e-15 * AccurateMath.abs(v[1].getValue()));
-            Assert.assertEquals(u[2], lin.getDerivative(2), 1.0e-15 * AccurateMath.abs(v[2].getValue()));
+            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * JdkMath.abs(ref));
+            Assert.assertEquals(u[0], lin.getDerivative(0), 1.0e-15 * JdkMath.abs(v[0].getValue()));
+            Assert.assertEquals(u[1], lin.getDerivative(1), 1.0e-15 * JdkMath.abs(v[1].getValue()));
+            Assert.assertEquals(u[2], lin.getDerivative(2), 1.0e-15 * JdkMath.abs(v[2].getValue()));
 
             lin = v[0].linearCombination(u[0], v[0], u[1], v[1], u[2], v[2], u[3], v[3]);
             ref = u[0] * v[0].getValue() +
                   u[1] * v[1].getValue() +
                   u[2] * v[2].getValue() +
                   u[3] * v[3].getValue();
-            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * AccurateMath.abs(ref));
-            Assert.assertEquals(u[0], lin.getDerivative(0), 1.0e-15 * AccurateMath.abs(v[0].getValue()));
-            Assert.assertEquals(u[1], lin.getDerivative(1), 1.0e-15 * AccurateMath.abs(v[1].getValue()));
-            Assert.assertEquals(u[2], lin.getDerivative(2), 1.0e-15 * AccurateMath.abs(v[2].getValue()));
-            Assert.assertEquals(u[3], lin.getDerivative(3), 1.0e-15 * AccurateMath.abs(v[3].getValue()));
+            Assert.assertEquals(ref, lin.getValue(), 1.0e-15 * JdkMath.abs(ref));
+            Assert.assertEquals(u[0], lin.getDerivative(0), 1.0e-15 * JdkMath.abs(v[0].getValue()));
+            Assert.assertEquals(u[1], lin.getDerivative(1), 1.0e-15 * JdkMath.abs(v[1].getValue()));
+            Assert.assertEquals(u[2], lin.getDerivative(2), 1.0e-15 * JdkMath.abs(v[2].getValue()));
+            Assert.assertEquals(u[3], lin.getDerivative(3), 1.0e-15 * JdkMath.abs(v[3].getValue()));
 
         }
     }
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/BivariateFunctionTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/BivariateFunctionTest.java
index 9039850..d68ab00 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/BivariateFunctionTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/BivariateFunctionTest.java
@@ -17,7 +17,7 @@
 
 package org.apache.commons.math4.legacy.analysis.function;
 
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -31,7 +31,7 @@
     @Test
     public void testAtan2() {
         Atan2 atan2 = new Atan2();
-        Assert.assertEquals(AccurateMath.PI/4,atan2.value(1,1), EPS);
+        Assert.assertEquals(JdkMath.PI/4,atan2.value(1,1), EPS);
     }
 
     @Test
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/GaussianTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/GaussianTest.java
index eed1276..1db6ca2 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/GaussianTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/GaussianTest.java
@@ -23,7 +23,7 @@
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
 import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -42,7 +42,7 @@
     public void testSomeValues() {
         final UnivariateFunction f = new Gaussian();
 
-        Assert.assertEquals(1 / AccurateMath.sqrt(2 * Math.PI), f.value(0), EPS);
+        Assert.assertEquals(1 / JdkMath.sqrt(2 * Math.PI), f.value(0), EPS);
     }
 
     @Test
@@ -151,7 +151,7 @@
         final double x = 1;
         final double[] grad = f.gradient(1, new double[] {norm, mean, sigma});
         final double diff = x - mean;
-        final double n = AccurateMath.exp(-diff * diff / (2 * sigma * sigma));
+        final double n = JdkMath.exp(-diff * diff / (2 * sigma * sigma));
         Assert.assertEquals(n, grad[0], EPS);
         final double m = norm * n * diff / (sigma * sigma);
         Assert.assertEquals(m, grad[1], EPS);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/HarmonicOscillatorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/HarmonicOscillatorTest.java
index 889f7ca..1860d10 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/HarmonicOscillatorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/HarmonicOscillatorTest.java
@@ -21,7 +21,7 @@
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.apache.commons.numbers.core.Precision;
 import org.junit.Assert;
 import org.junit.Test;
@@ -42,7 +42,7 @@
         final double d = 0.12345;
         for (int i = 0; i < 10; i++) {
             final double v = i * d;
-            Assert.assertEquals(a * AccurateMath.cos(w * v + p), f.value(v), 0);
+            Assert.assertEquals(a * JdkMath.cos(w * v + p), f.value(v), 0);
         }
     }
 
@@ -62,19 +62,19 @@
                     final double trigo;
                     switch (k % 4) {
                         case 0:
-                            trigo = +AccurateMath.cos(w * v + p);
+                            trigo = +JdkMath.cos(w * v + p);
                             break;
                         case 1:
-                            trigo = -AccurateMath.sin(w * v + p);
+                            trigo = -JdkMath.sin(w * v + p);
                             break;
                         case 2:
-                            trigo = -AccurateMath.cos(w * v + p);
+                            trigo = -JdkMath.cos(w * v + p);
                             break;
                         default:
-                            trigo = +AccurateMath.sin(w * v + p);
+                            trigo = +JdkMath.sin(w * v + p);
                             break;
                     }
-                    Assert.assertEquals(a * AccurateMath.pow(w, k) * trigo,
+                    Assert.assertEquals(a * JdkMath.pow(w, k) * trigo,
                                         h.getPartialDerivative(k),
                                         Precision.EPSILON);
                 }
@@ -129,11 +129,11 @@
         final double x = 1;
         final double[] grad = f.gradient(1, new double[] {amplitude, omega, phase});
         final double xTimesOmegaPlusPhase = omega * x + phase;
-        final double a = AccurateMath.cos(xTimesOmegaPlusPhase);
+        final double a = JdkMath.cos(xTimesOmegaPlusPhase);
         Assert.assertEquals(a, grad[0], EPS);
-        final double w = -amplitude * x * AccurateMath.sin(xTimesOmegaPlusPhase);
+        final double w = -amplitude * x * JdkMath.sin(xTimesOmegaPlusPhase);
         Assert.assertEquals(w, grad[1], EPS);
-        final double p = -amplitude * AccurateMath.sin(xTimesOmegaPlusPhase);
+        final double p = -amplitude * JdkMath.sin(xTimesOmegaPlusPhase);
         Assert.assertEquals(p, grad[2], EPS);
     }
 }
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/LogisticTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/LogisticTest.java
index f0525a8..b348be0 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/LogisticTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/LogisticTest.java
@@ -22,7 +22,7 @@
 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
 import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -70,7 +70,7 @@
 
         double x;
         x = m;
-        Assert.assertEquals("x=" + x, a + (k - a) / AccurateMath.sqrt(1 + q), f.value(x), EPS);
+        Assert.assertEquals("x=" + x, a + (k - a) / JdkMath.sqrt(1 + q), f.value(x), EPS);
 
         x = Double.NEGATIVE_INFINITY;
         Assert.assertEquals("x=" + x, a, f.value(x), EPS);
@@ -161,7 +161,7 @@
         final double k = 3.4;
         final double a = 2.3;
         final double q = 0.567;
-        final double b = -AccurateMath.log(q);
+        final double b = -JdkMath.log(q);
         final double n = 3.4;
 
         final Logistic.Parametric f = new Logistic.Parametric();
@@ -171,7 +171,7 @@
 
         final double[] gf = f.gradient(x, new double[] {k, m, b, q, a, n});
 
-        Assert.assertEquals((k - a) * AccurateMath.log(qExp1) / (n * n * AccurateMath.pow(qExp1, 1 / n)),
+        Assert.assertEquals((k - a) * JdkMath.log(qExp1) / (n * n * JdkMath.pow(qExp1, 1 / n)),
                             gf[5], EPS);
     }
 
@@ -181,7 +181,7 @@
         final double k = 3.4;
         final double a = 2.3;
         final double b = 0.567;
-        final double q = 1 / AccurateMath.exp(b * m);
+        final double q = 1 / JdkMath.exp(b * m);
         final double n = 3.4;
 
         final Logistic.Parametric f = new Logistic.Parametric();
@@ -191,7 +191,7 @@
 
         final double[] gf = f.gradient(x, new double[] {k, m, b, q, a, n});
 
-        final double factor = (a - k) / (n * AccurateMath.pow(qExp1, 1 / n + 1));
+        final double factor = (a - k) / (n * JdkMath.pow(qExp1, 1 / n + 1));
         Assert.assertEquals(factor * b, gf[1], EPS);
         Assert.assertEquals(factor * m, gf[2], EPS);
         Assert.assertEquals(factor / q, gf[3], EPS);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/LogitTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/LogitTest.java
index fe9ca52..88dc353 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/LogitTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/LogitTest.java
@@ -26,7 +26,7 @@
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
 import org.apache.commons.rng.simple.RandomSource;
 import org.apache.commons.rng.UniformRandomProvider;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -186,7 +186,7 @@
             for (int i = 0; i < 10; i++) {
                 final double x = lo + random.nextDouble() * (hi - lo);
                 final DerivativeStructure dsX = new DerivativeStructure(1, maxOrder, 0, x);
-                max = AccurateMath.max(max, AccurateMath.abs(dsX.getPartialDerivative(maxOrder) -
+                max = JdkMath.max(max, JdkMath.abs(dsX.getPartialDerivative(maxOrder) -
                                                      id.value(dsX).getPartialDerivative(maxOrder)));
                 Assert.assertEquals("maxOrder = " + maxOrder,
                                     dsX.getPartialDerivative(maxOrder),
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/SincTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/SincTest.java
index c0a6bbe..7d2aeb3 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/SincTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/SincTest.java
@@ -21,7 +21,7 @@
 import org.apache.commons.math4.legacy.core.dfp.Dfp;
 import org.apache.commons.math4.legacy.core.dfp.DfpField;
 import org.apache.commons.math4.legacy.core.dfp.DfpMath;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -68,7 +68,7 @@
        double prod = 1;
        double xOverPow2 = x / 2;
        while (xOverPow2 > 0) {
-           prod *= AccurateMath.cos(xOverPow2);
+           prod *= JdkMath.cos(xOverPow2);
            xOverPow2 /= 2;
        }
        Assert.assertEquals(prod, s.value(x), 1e-13);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/SqrtTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/SqrtTest.java
index dc88b73..81b99c8 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/SqrtTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/SqrtTest.java
@@ -19,7 +19,7 @@
 import org.apache.commons.math4.legacy.analysis.UnivariateFunction;
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
 import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -30,7 +30,7 @@
        final UnivariateFunction f = new UnivariateFunction() {
            @Override
            public double value(double x) {
-               return AccurateMath.sqrt(x);
+               return JdkMath.sqrt(x);
            }
        };
 
@@ -47,14 +47,14 @@
        final UnivariateFunction f = new UnivariateFunction() {
                @Override
             public double value(double x) {
-                   return 1 / (2 * AccurateMath.sqrt(x));
+                   return 1 / (2 * JdkMath.sqrt(x));
                }
            };
 
        for (double x = 1e-30; x < 1e10; x *= 2) {
            final double fX = f.value(x);
            final double sX = sPrime.value(new DerivativeStructure(1, 1, 0, x)).getPartialDerivative(1);
-           Assert.assertEquals("x=" + x, fX, sX, AccurateMath.ulp(fX));
+           Assert.assertEquals("x=" + x, fX, sX, JdkMath.ulp(fX));
        }
    }
 
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/UnivariateDifferentiableFunctionTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/UnivariateDifferentiableFunctionTest.java
index aebbd66..1af604d 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/UnivariateDifferentiableFunctionTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/UnivariateDifferentiableFunctionTest.java
@@ -18,7 +18,7 @@
 package org.apache.commons.math4.legacy.analysis.function;
 
 import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -32,10 +32,10 @@
     @Test
     public void testAcos() {
         Acos acos = new Acos();
-        Assert.assertEquals(AccurateMath.PI/3, acos.value(0.5), EPS);
-        Assert.assertEquals(AccurateMath.PI/4, acos.value(Double.valueOf(1/AccurateMath.sqrt(2))), EPS);
+        Assert.assertEquals(JdkMath.PI/3, acos.value(0.5), EPS);
+        Assert.assertEquals(JdkMath.PI/4, acos.value(Double.valueOf(1/JdkMath.sqrt(2))), EPS);
         double a = 0.5;
-        Assert.assertEquals(-1/AccurateMath.sqrt(1-AccurateMath.pow(a,2)), acos.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+        Assert.assertEquals(-1/JdkMath.sqrt(1-JdkMath.pow(a,2)), acos.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
     }
 
     @Test
@@ -43,48 +43,48 @@
         Acosh acosh = new Acosh();
         Assert.assertEquals(0,acosh.value(1), EPS);
         double a = 1.2345;
-        Assert.assertEquals(a,acosh.value(AccurateMath.cosh(a)), EPS);
-        Assert.assertEquals(1/(AccurateMath.sqrt(a-1)*AccurateMath.sqrt(a+1)),acosh.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+        Assert.assertEquals(a,acosh.value(JdkMath.cosh(a)), EPS);
+        Assert.assertEquals(1/(JdkMath.sqrt(a-1)*JdkMath.sqrt(a+1)),acosh.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
     }
 
     @Test
     public void testAsin() {
         Asin asin = new Asin();
         double a = 1.2345;
-        Assert.assertEquals(a, asin.value(AccurateMath.sin(a)), EPS);
-        Assert.assertEquals(1/AccurateMath.sqrt(1 - AccurateMath.pow(a,2)), asin.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+        Assert.assertEquals(a, asin.value(JdkMath.sin(a)), EPS);
+        Assert.assertEquals(1/JdkMath.sqrt(1 - JdkMath.pow(a,2)), asin.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
     }