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| < 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 < 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);
}
@Test
public void testAsinh() {
Asinh asinh = new Asinh();
double a = 1.2345;
- Assert.assertEquals(a, asinh.value(AccurateMath.sinh(a)), EPS);
- Assert.assertEquals(1/AccurateMath.sqrt(AccurateMath.pow(a,2.0) + 1), asinh.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ Assert.assertEquals(a, asinh.value(JdkMath.sinh(a)), EPS);
+ Assert.assertEquals(1/JdkMath.sqrt(JdkMath.pow(a,2.0) + 1), asinh.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
}
@Test
public void testAtan() {
Atan atan = new Atan();
double a = 1.2345;
- Assert.assertEquals(a, atan.value(AccurateMath.tan(a)), EPS);
- Assert.assertEquals(1/(AccurateMath.pow(a,2.0) + 1), atan.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ Assert.assertEquals(a, atan.value(JdkMath.tan(a)), EPS);
+ Assert.assertEquals(1/(JdkMath.pow(a,2.0) + 1), atan.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
}
@Test
public void testAtanh() {
Atanh atanh = new Atanh();
double a = 1.2345;
- Assert.assertEquals(a, atanh.value(AccurateMath.tanh(a)), EPS);
- Assert.assertEquals(1/(1 - AccurateMath.pow(a,2.0)), atanh.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ Assert.assertEquals(a, atanh.value(JdkMath.tanh(a)), EPS);
+ Assert.assertEquals(1/(1 - JdkMath.pow(a,2.0)), atanh.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
}
@Test
public void testCbrt() {
Cbrt cbrt = new Cbrt();
double a = 1.2345;
- Assert.assertEquals(a, cbrt.value(AccurateMath.pow(a,3)), EPS);
- Assert.assertEquals(1.0/(3.0*AccurateMath.pow(a, 2.0/3.0)), cbrt.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ Assert.assertEquals(a, cbrt.value(JdkMath.pow(a,3)), EPS);
+ Assert.assertEquals(1.0/(3.0*JdkMath.pow(a, 2.0/3.0)), cbrt.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
}
@Test
@@ -105,23 +105,23 @@
public void testCos() {
Cos cos = new Cos();
double a = 0.987;
- Assert.assertEquals(a, cos.value(AccurateMath.acos(a)), EPS);
- Assert.assertEquals(-AccurateMath.sin(a), cos.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ Assert.assertEquals(a, cos.value(JdkMath.acos(a)), EPS);
+ Assert.assertEquals(-JdkMath.sin(a), cos.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
}
@Test
public void testCosh() {
Cosh cosh = new Cosh();
double a = 1.2345;
- Assert.assertEquals(a, cosh.value(AccurateMath.acosh(a)), EPS);
- Assert.assertEquals(AccurateMath.sinh(a), cosh.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ Assert.assertEquals(a, cosh.value(JdkMath.acosh(a)), EPS);
+ Assert.assertEquals(JdkMath.sinh(a), cosh.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
}
@Test
public void testExp() {
Exp exp= new Exp();
double a = 1.2345;
- Assert.assertEquals(a, exp.value(AccurateMath.log(a)), EPS);
+ Assert.assertEquals(a, exp.value(JdkMath.log(a)), EPS);
Assert.assertEquals(exp.value(a), exp.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
}
@@ -129,8 +129,8 @@
public void testExpm1() {
Expm1 expm1 = new Expm1();
double a = 1.2345;
- Assert.assertEquals(a-1, expm1.value(AccurateMath.log(a)), EPS);
- Assert.assertEquals(AccurateMath.exp(a), expm1.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ Assert.assertEquals(a-1, expm1.value(JdkMath.log(a)), EPS);
+ Assert.assertEquals(JdkMath.exp(a), expm1.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
}
@Test
@@ -146,7 +146,7 @@
Inverse inverse = new Inverse();
double a = 123.456;
Assert.assertEquals(1/a, inverse.value(a), EPS);
- Assert.assertEquals(-1/AccurateMath.pow(a,2), inverse.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ Assert.assertEquals(-1/JdkMath.pow(a,2), inverse.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
}
@Test
@@ -161,15 +161,15 @@
public void testLog10() {
Log10 log10 = new Log10();
double a =1.2345;
- Assert.assertEquals(a, log10.value(AccurateMath.pow(10, a)), EPS);
- Assert.assertEquals(1/(a*AccurateMath.log(10)), log10.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ Assert.assertEquals(a, log10.value(JdkMath.pow(10, a)), EPS);
+ Assert.assertEquals(1/(a*JdkMath.log(10)), log10.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
}
@Test
public void testLog1p() {
Log1p log1p = new Log1p();
double a = 1.2345;
- Assert.assertEquals(a+1,AccurateMath.exp(log1p.value(a)), EPS);
+ Assert.assertEquals(a+1,JdkMath.exp(log1p.value(a)), EPS);
Assert.assertEquals(1/(1+a), log1p.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
}
@@ -186,42 +186,42 @@
Power squared = new Power(2);
Power power2_5 = new Power(2.5);
double a = 123.456;
- Assert.assertEquals(AccurateMath.pow(a,2), squared.value(a), EPS);
- Assert.assertEquals(AccurateMath.pow(a, 2.5), power2_5.value(a), EPS);
+ Assert.assertEquals(JdkMath.pow(a,2), squared.value(a), EPS);
+ Assert.assertEquals(JdkMath.pow(a, 2.5), power2_5.value(a), EPS);
Assert.assertEquals(2*a, squared.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
- Assert.assertEquals(2.5*AccurateMath.pow(a,1.5), power2_5.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ Assert.assertEquals(2.5*JdkMath.pow(a,1.5), power2_5.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
}
@Test
public void testSin() {
Sin sin = new Sin();
double a = 0.987;
- Assert.assertEquals(a, sin.value(AccurateMath.asin(a)), EPS);
- Assert.assertEquals(AccurateMath.cos(a), sin.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ Assert.assertEquals(a, sin.value(JdkMath.asin(a)), EPS);
+ Assert.assertEquals(JdkMath.cos(a), sin.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
}
@Test
public void testSinh() {
Sinh sinh = new Sinh();
double a = 1.2345;
- Assert.assertEquals(a, sinh.value(AccurateMath.asinh(a)), EPS);
- Assert.assertEquals(AccurateMath.cosh(a), sinh.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ Assert.assertEquals(a, sinh.value(JdkMath.asinh(a)), EPS);
+ Assert.assertEquals(JdkMath.cosh(a), sinh.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
}
@Test
public void testTan() {
Tan tan = new Tan();
double a = 0.987;
- Assert.assertEquals(a, tan.value(AccurateMath.atan(a)), EPS);
- Assert.assertEquals(1/(AccurateMath.pow(AccurateMath.cos(a),2)), tan.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ Assert.assertEquals(a, tan.value(JdkMath.atan(a)), EPS);
+ Assert.assertEquals(1/(JdkMath.pow(JdkMath.cos(a),2)), tan.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
}
@Test
public void testTanh() {
Tanh tanh = new Tanh();
double a = 0.987;
- Assert.assertEquals(a, tanh.value(AccurateMath.atanh(a)), EPS);
- Assert.assertEquals(1/AccurateMath.pow(AccurateMath.cosh(a),2), tanh.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ Assert.assertEquals(a, tanh.value(JdkMath.atanh(a)), EPS);
+ Assert.assertEquals(1/JdkMath.pow(JdkMath.cosh(a),2), tanh.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
}
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/UnivariateFunctionTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/UnivariateFunctionTest.java
index d19d1aa..da7d5e4 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/UnivariateFunctionTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/function/UnivariateFunctionTest.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;
import org.junit.Assert;
import org.junit.Test;
@@ -118,7 +118,7 @@
}
private double expectedUlp(double x) {
- return AccurateMath.abs(x - Double.longBitsToDouble(Double.doubleToRawLongBits(x) ^ 1));
+ return JdkMath.abs(x - Double.longBitsToDouble(Double.doubleToRawLongBits(x) ^ 1));
}
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/IterativeLegendreGaussIntegratorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/IterativeLegendreGaussIntegratorTest.java
index 61e210c..c2ad3fe 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/IterativeLegendreGaussIntegratorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/IterativeLegendreGaussIntegratorTest.java
@@ -24,7 +24,7 @@
import org.apache.commons.math4.legacy.analysis.function.Sin;
import org.apache.commons.math4.legacy.analysis.polynomials.PolynomialFunction;
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.junit.Assert;
import org.junit.Test;
@@ -42,15 +42,15 @@
double result;
double tolerance;
- min = 0; max = AccurateMath.PI; expected = 2;
- tolerance = AccurateMath.max(integrator.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * integrator.getRelativeAccuracy()));
+ min = 0; max = JdkMath.PI; expected = 2;
+ tolerance = JdkMath.max(integrator.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * integrator.getRelativeAccuracy()));
result = integrator.integrate(10000, f, min, max);
Assert.assertEquals(expected, result, tolerance);
- min = -AccurateMath.PI/3; max = 0; expected = -0.5;
- tolerance = AccurateMath.max(integrator.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * integrator.getRelativeAccuracy()));
+ min = -JdkMath.PI/3; max = 0; expected = -0.5;
+ tolerance = JdkMath.max(integrator.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * integrator.getRelativeAccuracy()));
result = integrator.integrate(10000, f, min, max);
Assert.assertEquals(expected, result, tolerance);
}
@@ -103,7 +103,7 @@
PolynomialFunction p = new PolynomialFunction(coeff);
double result = integrator.integrate(10000, p, -5.0, 15.0);
double reference = exactIntegration(p, -5.0, 15.0);
- Assert.assertEquals(n + " " + degree + " " + i, reference, result, 1.0e-12 * (1.0 + AccurateMath.abs(reference)));
+ Assert.assertEquals(n + " " + degree + " " + i, reference, result, 1.0e-12 * (1.0 + JdkMath.abs(reference)));
}
}
@@ -115,7 +115,7 @@
public void testNormalDistributionWithLargeSigma() {
final double sigma = 1000;
final double mean = 0;
- final double factor = 1 / (sigma * AccurateMath.sqrt(2 * AccurateMath.PI));
+ final double factor = 1 / (sigma * JdkMath.sqrt(2 * JdkMath.PI));
final UnivariateFunction normal = new Gaussian(factor, mean, sigma);
final double tol = 1e-2;
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/MidPointIntegratorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/MidPointIntegratorTest.java
index a6d9ae7..f02257b 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/MidPointIntegratorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/MidPointIntegratorTest.java
@@ -21,7 +21,7 @@
import org.apache.commons.math4.legacy.analysis.function.Sin;
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;
@@ -51,7 +51,7 @@
* (3^(n + 1) - 1) / 2 evaluations; just under 50% more.
*/
private long expectedEvaluations(int iterations) {
- return (long) AccurateMath.pow(3, iterations);
+ return (long) JdkMath.pow(3, iterations);
}
/**
@@ -65,7 +65,7 @@
double min = -10;
double max = -9;
double expected = -3697001.0 / 48.0;
- double tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ double tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
double result = integrator.integrate(Integer.MAX_VALUE, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < Integer.MAX_VALUE / 3);
Assert.assertTrue(integrator.getIterations() < NUM_ITER);
@@ -83,19 +83,19 @@
UnivariateIntegrator integrator = new MidPointIntegrator();
double min = 0;
- double max = AccurateMath.PI;
+ double max = JdkMath.PI;
double expected = 2;
- double tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ double tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
double result = integrator.integrate(Integer.MAX_VALUE, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < Integer.MAX_VALUE / 3);
Assert.assertTrue(integrator.getIterations() < NUM_ITER);
Assert.assertEquals(expectedEvaluations(integrator.getIterations()), integrator.getEvaluations());
Assert.assertEquals(expected, result, tolerance);
- min = -AccurateMath.PI/3;
+ min = -JdkMath.PI/3;
max = 0;
expected = -0.5;
- tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
result = integrator.integrate(Integer.MAX_VALUE, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < Integer.MAX_VALUE / 3);
Assert.assertTrue(integrator.getIterations() < NUM_ITER);
@@ -115,7 +115,7 @@
double min = 0;
double max = 1;
double expected = -1.0 / 48;
- double tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ double tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
double result = integrator.integrate(Integer.MAX_VALUE, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < Integer.MAX_VALUE / 3);
Assert.assertTrue(integrator.getIterations() < NUM_ITER);
@@ -125,7 +125,7 @@
min = 0;
max = 0.5;
expected = 11.0 / 768;
- tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
result = integrator.integrate(Integer.MAX_VALUE, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < Integer.MAX_VALUE / 3);
Assert.assertTrue(integrator.getIterations() < NUM_ITER);
@@ -134,7 +134,7 @@
min = -1;
max = 4;
expected = 2048 / 3.0 - 78 + 1.0 / 48;
- tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
result = integrator.integrate(Integer.MAX_VALUE, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < Integer.MAX_VALUE / 3);
Assert.assertTrue(integrator.getIterations() < NUM_ITER);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/RombergIntegratorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/RombergIntegratorTest.java
index 892b9ff..7a82599 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/RombergIntegratorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/RombergIntegratorTest.java
@@ -21,7 +21,7 @@
import org.apache.commons.math4.legacy.analysis.function.Sin;
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;
@@ -49,15 +49,15 @@
double result;
double tolerance;
- min = 0; max = AccurateMath.PI; expected = 2;
- tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ min = 0; max = JdkMath.PI; expected = 2;
+ tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
result = integrator.integrate(100, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < 50);
Assert.assertTrue(integrator.getIterations() < 10);
Assert.assertEquals(expected, result, tolerance);
- min = -AccurateMath.PI/3; max = 0; expected = -0.5;
- tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ min = -JdkMath.PI/3; max = 0; expected = -0.5;
+ tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
result = integrator.integrate(100, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < 50);
Assert.assertTrue(integrator.getIterations() < 10);
@@ -78,21 +78,21 @@
double tolerance;
min = 0; max = 1; expected = -1.0/48;
- tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
result = integrator.integrate(100, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < 10);
Assert.assertTrue(integrator.getIterations() < 5);
Assert.assertEquals(expected, result, tolerance);
min = 0; max = 0.5; expected = 11.0/768;
- tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
result = integrator.integrate(100, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < 10);
Assert.assertTrue(integrator.getIterations() < 5);
Assert.assertEquals(expected, result, tolerance);
min = -1; max = 4; expected = 2048/3.0 - 78 + 1.0/48;
- tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
result = integrator.integrate(100, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < 10);
Assert.assertTrue(integrator.getIterations() < 5);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/SimpsonIntegratorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/SimpsonIntegratorTest.java
index 66a82b5..b33eb4f 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/SimpsonIntegratorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/SimpsonIntegratorTest.java
@@ -23,7 +23,7 @@
import org.apache.commons.math4.legacy.analysis.function.Sin;
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;
@@ -51,15 +51,15 @@
double result;
double tolerance;
- min = 0; max = AccurateMath.PI; expected = 2;
- tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ min = 0; max = JdkMath.PI; expected = 2;
+ tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
result = integrator.integrate(1000, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < 100);
Assert.assertTrue(integrator.getIterations() < 10);
Assert.assertEquals(expected, result, tolerance);
- min = -AccurateMath.PI/3; max = 0; expected = -0.5;
- tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ min = -JdkMath.PI/3; max = 0; expected = -0.5;
+ tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
result = integrator.integrate(1000, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < 50);
Assert.assertTrue(integrator.getIterations() < 10);
@@ -80,21 +80,21 @@
double tolerance;
min = 0; max = 1; expected = -1.0/48;
- tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
result = integrator.integrate(1000, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < 150);
Assert.assertTrue(integrator.getIterations() < 10);
Assert.assertEquals(expected, result, tolerance);
min = 0; max = 0.5; expected = 11.0/768;
- tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
result = integrator.integrate(1000, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < 100);
Assert.assertTrue(integrator.getIterations() < 10);
Assert.assertEquals(expected, result, tolerance);
min = -1; max = 4; expected = 2048/3.0 - 78 + 1.0/48;
- tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
result = integrator.integrate(1000, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < 150);
Assert.assertTrue(integrator.getIterations() < 10);
@@ -173,7 +173,7 @@
double tolerance;
min = 0; max = 1; expected = 0.5;
- tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
result = integrator.integrate(1000, f, min, max);
// MATH-1458: No iterations were performed when minimalIterationCount==1
Assert.assertTrue("Iteration is not above 0",
@@ -259,7 +259,7 @@
double f01 = f.value(a + 1 * h);
double f0n = f.value(b);
expected = (b_a / 6) * (f00 + 4 * f01 + f0n);
- tolerance = AccurateMath.abs(expected * SimpsonIntegrator.DEFAULT_RELATIVE_ACCURACY);
+ tolerance = JdkMath.abs(expected * SimpsonIntegrator.DEFAULT_RELATIVE_ACCURACY);
result = computeSimpsonIteration(f, a, b, 0);
Assert.assertEquals("Result", expected, result, tolerance);
@@ -268,7 +268,7 @@
double f11 = f.value(a + 1 * h);
double f13 = f.value(a + 3 * h);
expected = (h / 3) * (f00 + 4 * f11 + 2 * f01 + 4 * f13 + f0n);
- tolerance = AccurateMath.abs(expected * SimpsonIntegrator.DEFAULT_RELATIVE_ACCURACY);
+ tolerance = JdkMath.abs(expected * SimpsonIntegrator.DEFAULT_RELATIVE_ACCURACY);
result = computeSimpsonIteration(f, a, b, 1);
Assert.assertEquals("Result", expected, result, tolerance);
@@ -280,7 +280,7 @@
double f27 = f.value(a + 7 * h);
expected = (h / 3) * (f00 + 4 * f21 + 2 * f11 + 4 * f23 + 2 * f01 + 4 * f25 +
2 * f13 + 4 * f27 + f0n);
- tolerance = AccurateMath.abs(expected * SimpsonIntegrator.DEFAULT_RELATIVE_ACCURACY);
+ tolerance = JdkMath.abs(expected * SimpsonIntegrator.DEFAULT_RELATIVE_ACCURACY);
result = computeSimpsonIteration(f, a, b, 2);
Assert.assertEquals("Result", expected, result, tolerance);
}
@@ -314,7 +314,7 @@
// Check the sum is as expected
expected = computeSimpsonIteration(f, min, max, 1);
- tolerance = AccurateMath.abs(expected * SimpsonIntegrator.DEFAULT_RELATIVE_ACCURACY);
+ tolerance = JdkMath.abs(expected * SimpsonIntegrator.DEFAULT_RELATIVE_ACCURACY);
Assert.assertEquals("Result", expected, result, tolerance);
}
@@ -344,7 +344,7 @@
// This is the expected sum.
// Each iteration will monotonically converge to this.
- expected = AccurateMath.log(max) - AccurateMath.log(min);
+ expected = JdkMath.log(max) - JdkMath.log(min);
// Test convergence at the given iteration
minIteration = 2;
@@ -368,7 +368,7 @@
}
// Check the test function is correct.
- tolerance = AccurateMath.abs(expected * SimpsonIntegrator.DEFAULT_RELATIVE_ACCURACY);
+ tolerance = JdkMath.abs(expected * SimpsonIntegrator.DEFAULT_RELATIVE_ACCURACY);
Assert.assertEquals("Expected result", expected, sums[maxIteration], tolerance);
// Set-up to test convergence at a specific iteration.
@@ -398,9 +398,9 @@
// MATH-1458: minimalIterationCount>1 computes incorrect Simpson sum
// for the iteration. Check it is the correct sum.
// It should be closer to this one than the previous or next.
- final double dp = AccurateMath.abs(sums[i-1] - result);
- final double d = AccurateMath.abs(sums[i] - result);
- final double dn = AccurateMath.abs(sums[i+1] - result);
+ final double dp = JdkMath.abs(sums[i-1] - result);
+ final double d = JdkMath.abs(sums[i] - result);
+ final double dn = JdkMath.abs(sums[i+1] - result);
Assert.assertTrue("Result closer to sum expected from previous iteration: " + i, d < dp);
Assert.assertTrue("Result closer to sum expected from next iteration: " + i, d < dn);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/TrapezoidIntegratorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/TrapezoidIntegratorTest.java
index e39a6a3..b09506a 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/TrapezoidIntegratorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/TrapezoidIntegratorTest.java
@@ -21,7 +21,7 @@
import org.apache.commons.math4.legacy.analysis.function.Sin;
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;
@@ -48,15 +48,15 @@
double result;
double tolerance;
- min = 0; max = AccurateMath.PI; expected = 2;
- tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ min = 0; max = JdkMath.PI; expected = 2;
+ tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
result = integrator.integrate(10000, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < 2500);
Assert.assertTrue(integrator.getIterations() < 15);
Assert.assertEquals(expected, result, tolerance);
- min = -AccurateMath.PI/3; max = 0; expected = -0.5;
- tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ min = -JdkMath.PI/3; max = 0; expected = -0.5;
+ tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
result = integrator.integrate(10000, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < 2500);
Assert.assertTrue(integrator.getIterations() < 15);
@@ -77,21 +77,21 @@
double tolerance;
min = 0; max = 1; expected = -1.0/48;
- tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
result = integrator.integrate(10000, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < 5000);
Assert.assertTrue(integrator.getIterations() < 15);
Assert.assertEquals(expected, result, tolerance);
min = 0; max = 0.5; expected = 11.0/768;
- tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
result = integrator.integrate(10000, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < 2500);
Assert.assertTrue(integrator.getIterations() < 15);
Assert.assertEquals(expected, result, tolerance);
min = -1; max = 4; expected = 2048/3.0 - 78 + 1.0/48;
- tolerance = AccurateMath.abs(expected * integrator.getRelativeAccuracy());
+ tolerance = JdkMath.abs(expected * integrator.getRelativeAccuracy());
result = integrator.integrate(10000, f, min, max);
Assert.assertTrue(integrator.getEvaluations() < 5000);
Assert.assertTrue(integrator.getIterations() < 15);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/gauss/GaussianQuadratureAbstractTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/gauss/GaussianQuadratureAbstractTest.java
index 3711c6e..aad4be3 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/gauss/GaussianQuadratureAbstractTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/gauss/GaussianQuadratureAbstractTest.java
@@ -17,7 +17,7 @@
package org.apache.commons.math4.legacy.analysis.integration.gauss;
import org.apache.commons.math4.legacy.analysis.function.Power;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
import org.junit.Test;
import org.junit.Assert;
@@ -105,7 +105,7 @@
integrator.getNumberOfPoints() + "-point quadrature rule",
expected, actual, eps);
} else {
- double err = AccurateMath.abs(actual - expected) / Math.ulp(expected);
+ double err = JdkMath.abs(actual - expected) / Math.ulp(expected);
Assert.assertEquals("while integrating monomial x**" + n + " with a " +
+ integrator.getNumberOfPoints() + "-point quadrature rule, " +
" error was " + err + " ulps",
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/gauss/HermiteParametricTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/gauss/HermiteParametricTest.java
index 06a3caf..74b4e62 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/gauss/HermiteParametricTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/gauss/HermiteParametricTest.java
@@ -22,7 +22,7 @@
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
/**
* Test of the {@link HermiteRuleFactory}.
@@ -34,7 +34,7 @@
*/
@RunWith(value=Parameterized.class)
public class HermiteParametricTest extends GaussianQuadratureAbstractTest {
- private static final double SQRT_PI = AccurateMath.sqrt(Math.PI);
+ private static final double SQRT_PI = JdkMath.sqrt(Math.PI);
private static final GaussIntegratorFactory factory = new GaussIntegratorFactory();
/**
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/gauss/HermiteTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/gauss/HermiteTest.java
index 1c094d9..91f1abc 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/gauss/HermiteTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/gauss/HermiteTest.java
@@ -17,7 +17,7 @@
package org.apache.commons.math4.legacy.analysis.integration.gauss;
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;
import org.junit.Test;
import org.junit.Assert;
@@ -30,7 +30,7 @@
@Test
public void testNormalDistribution() {
- final double oneOverSqrtPi = 1 / AccurateMath.sqrt(Math.PI);
+ final double oneOverSqrtPi = 1 / JdkMath.sqrt(Math.PI);
// By definition, Gauss-Hermite quadrature readily provides the
// integral of the normal distribution density.
@@ -57,8 +57,8 @@
@Test
public void testNormalMean() {
- final double sqrtTwo = AccurateMath.sqrt(2);
- final double oneOverSqrtPi = 1 / AccurateMath.sqrt(Math.PI);
+ final double sqrtTwo = JdkMath.sqrt(2);
+ final double oneOverSqrtPi = 1 / JdkMath.sqrt(Math.PI);
final double mu = 12345.6789;
final double sigma = 987.654321;
@@ -85,7 +85,7 @@
@Test
public void testNormalVariance() {
- final double twoOverSqrtPi = 2 / AccurateMath.sqrt(Math.PI);
+ final double twoOverSqrtPi = 2 / JdkMath.sqrt(Math.PI);
final double sigma = 987.654321;
final double sigma2 = sigma * sigma;
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/gauss/LaguerreTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/gauss/LaguerreTest.java
index c97f48c..d2961dd 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/gauss/LaguerreTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/integration/gauss/LaguerreTest.java
@@ -18,7 +18,7 @@
import org.apache.commons.math4.legacy.analysis.UnivariateFunction;
import org.apache.commons.numbers.gamma.Gamma;
-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;
@@ -38,7 +38,7 @@
final UnivariateFunction f = new UnivariateFunction() {
@Override
public double value(double x) {
- return AccurateMath.pow(x, t - 1);
+ return JdkMath.pow(x, t - 1);
}
};
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/AkimaSplineInterpolatorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/AkimaSplineInterpolatorTest.java
index f10f58a..c59a9bd 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/AkimaSplineInterpolatorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/AkimaSplineInterpolatorTest.java
@@ -28,7 +28,7 @@
import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
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.apache.commons.numbers.core.Precision;
import org.junit.Assert;
import org.junit.Test;
@@ -227,7 +227,7 @@
currentX = distX.sample();
expected = f.value(currentX);
actual = interpolation.value( currentX );
- sumError += AccurateMath.abs( actual - expected );
+ sumError += JdkMath.abs( actual - expected );
assertEquals( expected, actual, maxTolerance );
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/BicubicInterpolatingFunctionTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/BicubicInterpolatingFunctionTest.java
index a974ab2..173ff54 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/BicubicInterpolatingFunctionTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/BicubicInterpolatingFunctionTest.java
@@ -24,7 +24,7 @@
import org.apache.commons.math4.legacy.exception.OutOfRangeException;
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.apache.commons.numbers.core.Precision;
import org.junit.Assert;
import org.junit.Test;
@@ -374,7 +374,7 @@
}
actual = interpolation.value(currentX, currentY);
- sumError += AccurateMath.abs(actual - expected);
+ sumError += JdkMath.abs(actual - expected);
if (print) {
System.out.println(actual + " (diff=" + (expected - actual) + ")");
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/DividedDifferenceInterpolatorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/DividedDifferenceInterpolatorTest.java
index f9ebdb0..ea3bd32 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/DividedDifferenceInterpolatorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/DividedDifferenceInterpolatorTest.java
@@ -20,7 +20,7 @@
import org.apache.commons.math4.legacy.analysis.function.Expm1;
import org.apache.commons.math4.legacy.analysis.function.Sin;
import org.apache.commons.math4.legacy.exception.NonMonotonicSequenceException;
-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;
@@ -59,7 +59,7 @@
// 6 interpolating points on interval [0, 2*PI]
int n = 6;
double min = 0.0;
- double max = 2 * AccurateMath.PI;
+ double max = 2 * JdkMath.PI;
x = new double[n];
y = new double[n];
for (int i = 0; i < n; i++) {
@@ -69,12 +69,12 @@
double derivativebound = 1.0;
UnivariateFunction p = interpolator.interpolate(x, y);
- z = AccurateMath.PI / 4; expected = f.value(z); result = p.value(z);
- tolerance = AccurateMath.abs(derivativebound * partialerror(x, z));
+ z = JdkMath.PI / 4; expected = f.value(z); result = p.value(z);
+ tolerance = JdkMath.abs(derivativebound * partialerror(x, z));
Assert.assertEquals(expected, result, tolerance);
- z = AccurateMath.PI * 1.5; expected = f.value(z); result = p.value(z);
- tolerance = AccurateMath.abs(derivativebound * partialerror(x, z));
+ z = JdkMath.PI * 1.5; expected = f.value(z); result = p.value(z);
+ tolerance = JdkMath.abs(derivativebound * partialerror(x, z));
Assert.assertEquals(expected, result, tolerance);
}
@@ -104,19 +104,19 @@
x[i] = min + i * (max - min) / n;
y[i] = f.value(x[i]);
}
- double derivativebound = AccurateMath.E;
+ double derivativebound = JdkMath.E;
UnivariateFunction p = interpolator.interpolate(x, y);
z = 0.0; expected = f.value(z); result = p.value(z);
- tolerance = AccurateMath.abs(derivativebound * partialerror(x, z));
+ tolerance = JdkMath.abs(derivativebound * partialerror(x, z));
Assert.assertEquals(expected, result, tolerance);
z = 0.5; expected = f.value(z); result = p.value(z);
- tolerance = AccurateMath.abs(derivativebound * partialerror(x, z));
+ tolerance = JdkMath.abs(derivativebound * partialerror(x, z));
Assert.assertEquals(expected, result, tolerance);
z = -0.5; expected = f.value(z); result = p.value(z);
- tolerance = AccurateMath.abs(derivativebound * partialerror(x, z));
+ tolerance = JdkMath.abs(derivativebound * partialerror(x, z));
Assert.assertEquals(expected, result, tolerance);
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/FieldHermiteInterpolatorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/FieldHermiteInterpolatorTest.java
index d591208..fa42086 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/FieldHermiteInterpolatorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/FieldHermiteInterpolatorTest.java
@@ -24,7 +24,7 @@
import org.apache.commons.math4.legacy.linear.Dfp25;
import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
import org.apache.commons.math4.legacy.exception.NoDataException;
-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;
@@ -101,7 +101,7 @@
for (int k = 0; k < p.length; ++k) {
int degree = random.nextInt(7);
p[k] = randomPolynomial(degree, random);
- maxDegree = AccurateMath.max(maxDegree, degree);
+ maxDegree = JdkMath.max(maxDegree, degree);
}
DfpField field = new DfpField(30);
@@ -123,7 +123,7 @@
for (int k = 0; k < p.length; ++k) {
Assert.assertEquals(p[k].value(x.getReal()),
values[k].getReal(),
- 1.0e-8 * AccurateMath.abs(p[k].value(x.getReal())));
+ 1.0e-8 * JdkMath.abs(p[k].value(x.getReal())));
}
}
@@ -145,7 +145,7 @@
int degree = random.nextInt(7);
p[k] = randomPolynomial(degree, random);
pPrime[k] = p[k].polynomialDerivative();
- maxDegree = AccurateMath.max(maxDegree, degree);
+ maxDegree = JdkMath.max(maxDegree, degree);
}
DfpField field = new DfpField(30);
@@ -172,10 +172,10 @@
for (int k = 0; k < p.length; ++k) {
Assert.assertEquals(p[k].value(x.getReal()),
y[k].getReal(),
- 1.0e-8 * AccurateMath.abs(p[k].value(x.getReal())));
+ 1.0e-8 * JdkMath.abs(p[k].value(x.getReal())));
Assert.assertEquals(pPrime[k].value(x.getReal()),
yP[k].subtract(yM[k]).divide(h.multiply(2)).getReal(),
- 4.0e-8 * AccurateMath.abs(p[k].value(x.getReal())));
+ 4.0e-8 * JdkMath.abs(p[k].value(x.getReal())));
}
}
@@ -186,7 +186,7 @@
public void testSine() {
DfpField field = new DfpField(30);
FieldHermiteInterpolator<Dfp> interpolator = new FieldHermiteInterpolator<>();
- for (Dfp x = field.getZero(); x.getReal() < AccurateMath.PI; x = x.add(0.5)) {
+ for (Dfp x = field.getZero(); x.getReal() < JdkMath.PI; x = x.add(0.5)) {
interpolator.addSamplePoint(x, new Dfp[] { x.sin() });
}
for (Dfp x = field.newDfp(0.1); x.getReal() < 2.9; x = x.add(0.01)) {
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/HermiteInterpolatorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/HermiteInterpolatorTest.java
index 4712206..e984fc7 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/HermiteInterpolatorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/HermiteInterpolatorTest.java
@@ -22,7 +22,7 @@
import org.apache.commons.math4.legacy.analysis.polynomials.PolynomialFunction;
import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
import org.apache.commons.math4.legacy.exception.NoDataException;
-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;
@@ -86,7 +86,7 @@
for (int k = 0; k < p.length; ++k) {
int degree = random.nextInt(7);
p[k] = randomPolynomial(degree, random);
- maxDegree = AccurateMath.max(maxDegree, degree);
+ maxDegree = JdkMath.max(maxDegree, degree);
}
HermiteInterpolator interpolator = new HermiteInterpolator();
@@ -103,7 +103,7 @@
double[] values = interpolator.value(x);
Assert.assertEquals(p.length, values.length);
for (int k = 0; k < p.length; ++k) {
- Assert.assertEquals(p[k].value(x), values[k], 1.0e-8 * AccurateMath.abs(p[k].value(x)));
+ Assert.assertEquals(p[k].value(x), values[k], 1.0e-8 * JdkMath.abs(p[k].value(x)));
}
}
@@ -129,7 +129,7 @@
int degree = random.nextInt(7);
p[k] = randomPolynomial(degree, random);
pPrime[k] = p[k].polynomialDerivative();
- maxDegree = AccurateMath.max(maxDegree, degree);
+ maxDegree = JdkMath.max(maxDegree, degree);
}
HermiteInterpolator interpolator = new HermiteInterpolator();
@@ -148,8 +148,8 @@
DerivativeStructure[] y = interpolator.value(new DerivativeStructure(1, 1, 0, x));
Assert.assertEquals(p.length, y.length);
for (int k = 0; k < p.length; ++k) {
- Assert.assertEquals(p[k].value(x), y[k].getValue(), 1.0e-8 * AccurateMath.abs(p[k].value(x)));
- Assert.assertEquals(pPrime[k].value(x), y[k].getPartialDerivative(1), 4.0e-8 * AccurateMath.abs(p[k].value(x)));
+ Assert.assertEquals(p[k].value(x), y[k].getValue(), 1.0e-8 * JdkMath.abs(p[k].value(x)));
+ Assert.assertEquals(pPrime[k].value(x), y[k].getPartialDerivative(1), 4.0e-8 * JdkMath.abs(p[k].value(x)));
}
}
@@ -164,14 +164,14 @@
@Test
public void testSine() {
HermiteInterpolator interpolator = new HermiteInterpolator();
- for (double x = 0; x < AccurateMath.PI; x += 0.5) {
- interpolator.addSamplePoint(x, new double[] { AccurateMath.sin(x) });
+ for (double x = 0; x < JdkMath.PI; x += 0.5) {
+ interpolator.addSamplePoint(x, new double[] { JdkMath.sin(x) });
}
for (double x = 0.1; x <= 2.9; x += 0.01) {
DerivativeStructure y = interpolator.value(new DerivativeStructure(1, 2, 0, x))[0];
- Assert.assertEquals( AccurateMath.sin(x), y.getValue(), 3.5e-5);
- Assert.assertEquals( AccurateMath.cos(x), y.getPartialDerivative(1), 1.3e-4);
- Assert.assertEquals(-AccurateMath.sin(x), y.getPartialDerivative(2), 2.9e-3);
+ Assert.assertEquals( JdkMath.sin(x), y.getValue(), 3.5e-5);
+ Assert.assertEquals( JdkMath.cos(x), y.getPartialDerivative(1), 1.3e-4);
+ Assert.assertEquals(-JdkMath.sin(x), y.getPartialDerivative(2), 2.9e-3);
}
}
@@ -179,12 +179,12 @@
public void testSquareRoot() {
HermiteInterpolator interpolator = new HermiteInterpolator();
for (double x = 1.0; x < 3.6; x += 0.5) {
- interpolator.addSamplePoint(x, new double[] { AccurateMath.sqrt(x) });
+ interpolator.addSamplePoint(x, new double[] { JdkMath.sqrt(x) });
}
for (double x = 1.1; x < 3.5; x += 0.01) {
DerivativeStructure y = interpolator.value(new DerivativeStructure(1, 1, 0, x))[0];
- Assert.assertEquals(AccurateMath.sqrt(x), y.getValue(), 1.5e-4);
- Assert.assertEquals(0.5 / AccurateMath.sqrt(x), y.getPartialDerivative(1), 8.5e-4);
+ Assert.assertEquals(JdkMath.sqrt(x), y.getValue(), 1.5e-4);
+ Assert.assertEquals(0.5 / JdkMath.sqrt(x), y.getPartialDerivative(1), 8.5e-4);
}
}
@@ -246,7 +246,7 @@
double[] cE = expected.getCoefficients();
double[] cR = result.getCoefficients();
for (int i = 0; i < cE.length; ++i) {
- Assert.assertEquals(cE[i], cR[i], 1.0e-8 * AccurateMath.abs(cE[i]));
+ Assert.assertEquals(cE[i], cR[i], 1.0e-8 * JdkMath.abs(cE[i]));
}
for (int i = cE.length; i < cR.length; ++i) {
Assert.assertEquals(0.0, cR[i], 1.0e-9);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/LoessInterpolatorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/LoessInterpolatorTest.java
index 5e2f9eb..61aa3f1 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/LoessInterpolatorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/LoessInterpolatorTest.java
@@ -22,7 +22,7 @@
import org.apache.commons.math4.legacy.exception.NotFiniteNumberException;
import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
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.junit.Assert;
import org.junit.Test;
@@ -83,12 +83,12 @@
double fitResidualSum = 0;
for(int i = 0; i < numPoints; ++i) {
- double expected = AccurateMath.sin(xval[i]);
+ double expected = JdkMath.sin(xval[i]);
double noisy = yval[i];
double fit = res[i];
- noisyResidualSum += AccurateMath.pow(noisy - expected, 2);
- fitResidualSum += AccurateMath.pow(fit - expected, 2);
+ noisyResidualSum += JdkMath.pow(noisy - expected, 2);
+ fitResidualSum += JdkMath.pow(fit - expected, 2);
}
Assert.assertTrue(fitResidualSum < noisyResidualSum);
@@ -116,7 +116,7 @@
double[] res = li.smooth(xval, yval);
for (int j = 1; j < res.length; ++j) {
- variances[i] += AccurateMath.pow(res[j] - res[j-1], 2);
+ variances[i] += JdkMath.pow(res[j] - res[j-1], 2);
}
}
@@ -149,7 +149,7 @@
double[] res = li.smooth(xval, yval);
for (int j = 1; j < res.length; ++j) {
- variances[i] += AccurateMath.abs(res[j] - res[j-1]);
+ variances[i] += JdkMath.abs(res[j] - res[j-1]);
}
}
@@ -324,12 +324,12 @@
}
private void generateSineData(double[] xval, double[] yval, double xnoise, double ynoise) {
- double dx = 2 * AccurateMath.PI / xval.length;
+ double dx = 2 * JdkMath.PI / xval.length;
double x = 0;
for(int i = 0; i < xval.length; ++i) {
xval[i] = x;
- yval[i] = AccurateMath.sin(x) + (2 * AccurateMath.random() - 1) * ynoise;
- x += dx * (1 + (2 * AccurateMath.random() - 1) * xnoise);
+ yval[i] = JdkMath.sin(x) + (2 * JdkMath.random() - 1) * ynoise;
+ x += dx * (1 + (2 * JdkMath.random() - 1) * xnoise);
}
}
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/MicrosphereProjectionInterpolatorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/MicrosphereProjectionInterpolatorTest.java
index 74e1b94..e827bca 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/MicrosphereProjectionInterpolatorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/MicrosphereProjectionInterpolatorTest.java
@@ -17,7 +17,7 @@
package org.apache.commons.math4.legacy.analysis.interpolation;
import org.apache.commons.math4.legacy.analysis.MultivariateFunction;
-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;
@@ -104,8 +104,8 @@
expected = f.value(c);
result = p.value(c);
result2D = p2D.value(c);
- Assert.assertEquals("on sample point (exact)", expected, result2D, AccurateMath.ulp(1d));
- Assert.assertEquals("on sample point (ND vs 2D)", result2D, result, AccurateMath.ulp(1d));
+ Assert.assertEquals("on sample point (exact)", expected, result2D, JdkMath.ulp(1d));
+ Assert.assertEquals("on sample point (ND vs 2D)", result2D, result, JdkMath.ulp(1d));
// Interpolation.
c[0] = 0.654321;
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/NevilleInterpolatorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/NevilleInterpolatorTest.java
index 7c37d86..77ee29a 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/NevilleInterpolatorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/NevilleInterpolatorTest.java
@@ -20,7 +20,7 @@
import org.apache.commons.math4.legacy.analysis.function.Expm1;
import org.apache.commons.math4.legacy.analysis.function.Sin;
import org.apache.commons.math4.legacy.exception.NonMonotonicSequenceException;
-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;
@@ -59,7 +59,7 @@
// 6 interpolating points on interval [0, 2*PI]
int n = 6;
double min = 0.0;
- double max = 2 * AccurateMath.PI;
+ double max = 2 * JdkMath.PI;
x = new double[n];
y = new double[n];
for (int i = 0; i < n; i++) {
@@ -69,12 +69,12 @@
double derivativebound = 1.0;
UnivariateFunction p = interpolator.interpolate(x, y);
- z = AccurateMath.PI / 4; expected = f.value(z); result = p.value(z);
- tolerance = AccurateMath.abs(derivativebound * partialerror(x, z));
+ z = JdkMath.PI / 4; expected = f.value(z); result = p.value(z);
+ tolerance = JdkMath.abs(derivativebound * partialerror(x, z));
Assert.assertEquals(expected, result, tolerance);
- z = AccurateMath.PI * 1.5; expected = f.value(z); result = p.value(z);
- tolerance = AccurateMath.abs(derivativebound * partialerror(x, z));
+ z = JdkMath.PI * 1.5; expected = f.value(z); result = p.value(z);
+ tolerance = JdkMath.abs(derivativebound * partialerror(x, z));
Assert.assertEquals(expected, result, tolerance);
}
@@ -104,19 +104,19 @@
x[i] = min + i * (max - min) / n;
y[i] = f.value(x[i]);
}
- double derivativebound = AccurateMath.E;
+ double derivativebound = JdkMath.E;
UnivariateFunction p = interpolator.interpolate(x, y);
z = 0.0; expected = f.value(z); result = p.value(z);
- tolerance = AccurateMath.abs(derivativebound * partialerror(x, z));
+ tolerance = JdkMath.abs(derivativebound * partialerror(x, z));
Assert.assertEquals(expected, result, tolerance);
z = 0.5; expected = f.value(z); result = p.value(z);
- tolerance = AccurateMath.abs(derivativebound * partialerror(x, z));
+ tolerance = JdkMath.abs(derivativebound * partialerror(x, z));
Assert.assertEquals(expected, result, tolerance);
z = -0.5; expected = f.value(z); result = p.value(z);
- tolerance = AccurateMath.abs(derivativebound * partialerror(x, z));
+ tolerance = JdkMath.abs(derivativebound * partialerror(x, z));
Assert.assertEquals(expected, result, tolerance);
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunctionTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunctionTest.java
index 71fa711..26dca87 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunctionTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunctionTest.java
@@ -25,7 +25,7 @@
import org.apache.commons.math4.legacy.exception.NullArgumentException;
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.apache.commons.numbers.core.Precision;
import org.junit.Assert;
import org.junit.Test;
@@ -261,7 +261,7 @@
currentY = distY.sample();
expected = f.value(currentX, currentY);
actual = interpolation.value(currentX, currentY);
- sumError += AccurateMath.abs(actual - expected);
+ sumError += JdkMath.abs(actual - expected);
Assert.assertEquals(expected, actual, maxTolerance);
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/SplineInterpolatorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/SplineInterpolatorTest.java
index 005497d..888b30a 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/SplineInterpolatorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/SplineInterpolatorTest.java
@@ -23,7 +23,7 @@
import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
import org.apache.commons.math4.legacy.exception.NonMonotonicSequenceException;
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;
@@ -113,14 +113,14 @@
double x[] =
{
0.0,
- AccurateMath.PI / 6d,
- AccurateMath.PI / 2d,
- 5d * AccurateMath.PI / 6d,
- AccurateMath.PI,
- 7d * AccurateMath.PI / 6d,
- 3d * AccurateMath.PI / 2d,
- 11d * AccurateMath.PI / 6d,
- 2.d * AccurateMath.PI };
+ JdkMath.PI / 6d,
+ JdkMath.PI / 2d,
+ 5d * JdkMath.PI / 6d,
+ JdkMath.PI,
+ 7d * JdkMath.PI / 6d,
+ 3d * JdkMath.PI / 2d,
+ 11d * JdkMath.PI / 6d,
+ 2.d * JdkMath.PI };
double y[] = { 0d, 0.5d, 1d, 0.5d, 0d, -0.5d, -1d, -0.5d, 0d };
UnivariateInterpolator i = new SplineInterpolator();
UnivariateFunction f = i.interpolate(x, y);
@@ -155,8 +155,8 @@
TestUtils.assertEquals(polynomials[7].getCoefficients(), target, sineCoefficientTolerance);
//Check interpolation
- Assert.assertEquals(AccurateMath.sqrt(2d) / 2d,f.value(AccurateMath.PI/4d),sineInterpolationTolerance);
- Assert.assertEquals(AccurateMath.sqrt(2d) / 2d,f.value(3d*AccurateMath.PI/4d),sineInterpolationTolerance);
+ Assert.assertEquals(JdkMath.sqrt(2d) / 2d,f.value(JdkMath.PI/4d),sineInterpolationTolerance);
+ Assert.assertEquals(JdkMath.sqrt(2d) / 2d,f.value(3d*JdkMath.PI/4d),sineInterpolationTolerance);
}
@Test
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolatingFunctionTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolatingFunctionTest.java
index 87f7036..7ce5b63 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolatingFunctionTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolatingFunctionTest.java
@@ -23,7 +23,7 @@
import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
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.apache.commons.numbers.core.Precision;
import org.junit.Assert;
import org.junit.Test;
@@ -393,7 +393,7 @@
expected = f.value(currentX, currentY, currentZ);
actual = interpolation.value(currentX, currentY, currentZ);
- final double relativeError = AccurateMath.abs(actual - expected) / AccurateMath.max(AccurateMath.abs(actual), AccurateMath.abs(expected));
+ final double relativeError = JdkMath.abs(actual - expected) / JdkMath.max(JdkMath.abs(actual), JdkMath.abs(expected));
sumError += relativeError;
if (print) {
@@ -579,56 +579,56 @@
final TrivariateFunction f = new TrivariateFunction() {
@Override
public double value(double x, double y, double z) {
- return a * AccurateMath.cos(arg.value(x, y, z));
+ return a * JdkMath.cos(arg.value(x, y, z));
}
};
final TrivariateFunction dfdx = new TrivariateFunction() {
@Override
public double value(double x, double y, double z) {
- return kx * a * AccurateMath.sin(arg.value(x, y, z));
+ return kx * a * JdkMath.sin(arg.value(x, y, z));
}
};
final TrivariateFunction dfdy = new TrivariateFunction() {
@Override
public double value(double x, double y, double z) {
- return ky * a * AccurateMath.sin(arg.value(x, y, z));
+ return ky * a * JdkMath.sin(arg.value(x, y, z));
}
};
final TrivariateFunction dfdz = new TrivariateFunction() {
@Override
public double value(double x, double y, double z) {
- return -omega * a * AccurateMath.sin(arg.value(x, y, z));
+ return -omega * a * JdkMath.sin(arg.value(x, y, z));
}
};
final TrivariateFunction d2fdxdy = new TrivariateFunction() {
@Override
public double value(double x, double y, double z) {
- return -ky * kx * a * AccurateMath.cos(arg.value(x, y, z));
+ return -ky * kx * a * JdkMath.cos(arg.value(x, y, z));
}
};
final TrivariateFunction d2fdxdz = new TrivariateFunction() {
@Override
public double value(double x, double y, double z) {
- return omega * kx * a * AccurateMath.cos(arg.value(x, y, z));
+ return omega * kx * a * JdkMath.cos(arg.value(x, y, z));
}
};
final TrivariateFunction d2fdydz = new TrivariateFunction() {
@Override
public double value(double x, double y, double z) {
- return omega * ky * a * AccurateMath.cos(arg.value(x, y, z));
+ return omega * ky * a * JdkMath.cos(arg.value(x, y, z));
}
};
final TrivariateFunction d3fdxdydz = new TrivariateFunction() {
@Override
public double value(double x, double y, double z) {
- return omega * ky * kx * a * AccurateMath.sin(arg.value(x, y, z));
+ return omega * ky * kx * a * JdkMath.sin(arg.value(x, y, z));
}
};
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolatorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolatorTest.java
index 00932e8..0e2e140 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolatorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolatorTest.java
@@ -19,7 +19,7 @@
import org.apache.commons.math4.legacy.analysis.TrivariateFunction;
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.Assert;
import org.junit.Test;
@@ -190,7 +190,7 @@
TrivariateFunction f = new TrivariateFunction() {
@Override
public double value(double x, double y, double z) {
- return a * AccurateMath.cos(omega * z - kx * x - ky * y);
+ return a * JdkMath.cos(omega * z - kx * x - ky * y);
}
};
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/UnivariatePeriodicInterpolatorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/UnivariatePeriodicInterpolatorTest.java
index f4b9b27..cbadebd 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/UnivariatePeriodicInterpolatorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/interpolation/UnivariatePeriodicInterpolatorTest.java
@@ -25,7 +25,7 @@
import org.apache.commons.math4.legacy.analysis.UnivariateFunction;
import org.apache.commons.math4.legacy.exception.NonMonotonicSequenceException;
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;
/**
@@ -46,7 +46,7 @@
for (int i = 0; i < n; i++) {
delta += rng.nextDouble() * period / n;
xval[i] = offset + delta;
- yval[i] = AccurateMath.sin(xval[i]);
+ yval[i] = JdkMath.sin(xval[i]);
}
final UnivariateInterpolator inter = new LinearInterpolator();
@@ -91,7 +91,7 @@
for (int i = 0; i < n; i++) {
delta += period / (2 * n) * rng.nextDouble();
xval[i] = offset + delta;
- yval[i] = AccurateMath.sin(xval[i]);
+ yval[i] = JdkMath.sin(xval[i]);
}
final UnivariateInterpolator interP
@@ -122,7 +122,7 @@
for (int i = 0; i < n; i++) {
delta += 10 * period / n * rng.nextDouble();
xval[i] = offset + delta;
- yval[i] = AccurateMath.sin(xval[i]);
+ yval[i] = JdkMath.sin(xval[i]);
}
final UnivariateInterpolator interP
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialFunctionTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialFunctionTest.java
index 298515b..4a7d3f1 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialFunctionTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialFunctionTest.java
@@ -17,7 +17,7 @@
package org.apache.commons.math4.legacy.analysis.polynomials;
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;
@@ -148,8 +148,8 @@
Assert.assertEquals(f.polynomialDerivative().value(-3.25), g.value(-3.25), tolerance);
// compare g' = h
- Assert.assertEquals(g.polynomialDerivative().value(AccurateMath.PI), h.value(AccurateMath.PI), tolerance);
- Assert.assertEquals(g.polynomialDerivative().value(AccurateMath.E), h.value(AccurateMath.E), tolerance);
+ Assert.assertEquals(g.polynomialDerivative().value(JdkMath.PI), h.value(JdkMath.PI), tolerance);
+ Assert.assertEquals(g.polynomialDerivative().value(JdkMath.E), h.value(JdkMath.E), tolerance);
}
@Test
@@ -247,8 +247,8 @@
Assert.assertEquals(f.polynomialDerivative().value(-3.25), g.value(-3.25), tolerance);
// compare g' = h
- Assert.assertEquals(g.polynomialDerivative().value(AccurateMath.PI), h.value(AccurateMath.PI), tolerance);
- Assert.assertEquals(g.polynomialDerivative().value(AccurateMath.E), h.value(AccurateMath.E), tolerance);
+ Assert.assertEquals(g.polynomialDerivative().value(JdkMath.PI), h.value(JdkMath.PI), tolerance);
+ Assert.assertEquals(g.polynomialDerivative().value(JdkMath.E), h.value(JdkMath.E), tolerance);
}
public void checkPolynomial(PolynomialFunction p, String reference) {
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialsUtilsTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialsUtilsTest.java
index 5a4a498..ca38645 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialsUtilsTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialsUtilsTest.java
@@ -19,7 +19,7 @@
import org.apache.commons.math4.legacy.analysis.UnivariateFunction;
import org.apache.commons.math4.legacy.analysis.integration.IterativeLegendreGaussIntegrator;
import org.apache.commons.numbers.combinatorics.BinomialCoefficient;
-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;
@@ -49,7 +49,7 @@
for (int k = 0; k < 12; ++k) {
PolynomialFunction Tk = PolynomialsUtils.createChebyshevPolynomial(k);
for (double x = -1; x <= 1; x += 0.02) {
- Assert.assertTrue(k + " " + Tk.value(x), AccurateMath.abs(Tk.value(x)) < (1 + 1e-12));
+ Assert.assertTrue(k + " " + Tk.value(x), JdkMath.abs(Tk.value(x)) < (1 + 1e-12));
}
}
}
@@ -80,7 +80,7 @@
UnivariateFunction weight = new UnivariateFunction() {
@Override
public double value(double x) {
- return 1 / AccurateMath.sqrt(1 - x * x);
+ return 1 / JdkMath.sqrt(1 - x * x);
}
};
for (int i = 0; i < 10; ++i) {
@@ -132,7 +132,7 @@
UnivariateFunction weight = new UnivariateFunction() {
@Override
public double value(double x) {
- return AccurateMath.exp(-x * x);
+ return JdkMath.exp(-x * x);
}
};
for (int i = 0; i < 10; ++i) {
@@ -190,7 +190,7 @@
UnivariateFunction weight = new UnivariateFunction() {
@Override
public double value(double x) {
- return AccurateMath.exp(-x);
+ return JdkMath.exp(-x);
}
};
for (int i = 0; i < 10; ++i) {
@@ -270,7 +270,7 @@
for (int i = 0; i < l40.length; ++i) {
if (i % 2 == 0) {
double ci = numerators[i / 2] / denominator;
- Assert.assertEquals(ci, l40[i], AccurateMath.abs(ci) * 1e-15);
+ Assert.assertEquals(ci, l40[i], JdkMath.abs(ci) * 1e-15);
} else {
Assert.assertEquals(0, l40[i], 0);
}
@@ -308,7 +308,7 @@
UnivariateFunction weight = new UnivariateFunction() {
@Override
public double value(double x) {
- return AccurateMath.pow(1 - x, vv) * AccurateMath.pow(1 + x, ww);
+ return JdkMath.pow(1 - x, vv) * JdkMath.pow(1 + x, ww);
}
};
for (int i = 0; i < 10; ++i) {
@@ -384,11 +384,11 @@
if (p1.degree() == p2.degree()) {
// integral should be non-zero
Assert.assertTrue("I(" + p1.degree() + ", " + p2.degree() + ") = "+ dotProduct,
- AccurateMath.abs(dotProduct) > nonZeroThreshold);
+ JdkMath.abs(dotProduct) > nonZeroThreshold);
} else {
// integral should be zero
Assert.assertEquals("I(" + p1.degree() + ", " + p2.degree() + ") = "+ dotProduct,
- 0.0, AccurateMath.abs(dotProduct), zeroThreshold);
+ 0.0, JdkMath.abs(dotProduct), zeroThreshold);
}
}
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/BaseSecantSolverAbstractTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/BaseSecantSolverAbstractTest.java
index cf90ac3..b057aad 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/BaseSecantSolverAbstractTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/BaseSecantSolverAbstractTest.java
@@ -22,7 +22,7 @@
import org.apache.commons.math4.legacy.analysis.function.Sin;
import org.apache.commons.math4.legacy.exception.NoBracketingException;
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;
@@ -57,12 +57,12 @@
result = solver.solve(100, f, 3, 4);
//System.out.println(
// "Root: " + result + " Evaluations: " + solver.getEvaluations());
- Assert.assertEquals(result, AccurateMath.PI, solver.getAbsoluteAccuracy());
+ Assert.assertEquals(result, JdkMath.PI, solver.getAbsoluteAccuracy());
Assert.assertTrue(solver.getEvaluations() <= 6);
result = solver.solve(100, f, 1, 4);
//System.out.println(
// "Root: " + result + " Evaluations: " + solver.getEvaluations());
- Assert.assertEquals(result, AccurateMath.PI, solver.getAbsoluteAccuracy());
+ Assert.assertEquals(result, JdkMath.PI, solver.getAbsoluteAccuracy());
Assert.assertTrue(solver.getEvaluations() <= 7);
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/BisectionSolverTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/BisectionSolverTest.java
index 70c9ee3..e0b6fd7 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/BisectionSolverTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/BisectionSolverTest.java
@@ -19,7 +19,7 @@
import org.apache.commons.math4.legacy.analysis.QuinticFunction;
import org.apache.commons.math4.legacy.analysis.UnivariateFunction;
import org.apache.commons.math4.legacy.analysis.function.Sin;
-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;
@@ -33,10 +33,10 @@
BisectionSolver solver = new BisectionSolver();
result = solver.solve(100, f, 3, 4);
- Assert.assertEquals(result, AccurateMath.PI, solver.getAbsoluteAccuracy());
+ Assert.assertEquals(result, JdkMath.PI, solver.getAbsoluteAccuracy());
result = solver.solve(100, f, 1, 4);
- Assert.assertEquals(result, AccurateMath.PI, solver.getAbsoluteAccuracy());
+ Assert.assertEquals(result, JdkMath.PI, solver.getAbsoluteAccuracy());
}
@Test
@@ -85,6 +85,6 @@
public void testMath369() {
UnivariateFunction f = new Sin();
BisectionSolver solver = new BisectionSolver();
- Assert.assertEquals(AccurateMath.PI, solver.solve(100, f, 3.0, 3.2, 3.1), solver.getAbsoluteAccuracy());
+ Assert.assertEquals(JdkMath.PI, solver.solve(100, f, 3.0, 3.2, 3.1), solver.getAbsoluteAccuracy());
}
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/BrentSolverTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/BrentSolverTest.java
index 174055d..fc2dfdd 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/BrentSolverTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/BrentSolverTest.java
@@ -29,7 +29,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;
import org.junit.Assert;
import org.junit.Test;
@@ -56,13 +56,13 @@
result = solver.solve(100, f, 3, 4);
// System.out.println(
// "Root: " + result + " Evaluations: " + solver.getEvaluations());
- Assert.assertEquals(result, AccurateMath.PI, solver.getAbsoluteAccuracy());
+ Assert.assertEquals(result, JdkMath.PI, solver.getAbsoluteAccuracy());
Assert.assertTrue(solver.getEvaluations() <= 7);
// Larger and somewhat less benign interval. The function is grows first.
result = solver.solve(100, f, 1, 4);
// System.out.println(
// "Root: " + result + " Evaluations: " + solver.getEvaluations());
- Assert.assertEquals(result, AccurateMath.PI, solver.getAbsoluteAccuracy());
+ Assert.assertEquals(result, JdkMath.PI, solver.getAbsoluteAccuracy());
Assert.assertTrue(solver.getEvaluations() <= 8);
}
@@ -166,17 +166,17 @@
BrentSolver solver = new BrentSolver();
// endpoint is root
- double result = solver.solve(100, f, AccurateMath.PI, 4);
- Assert.assertEquals(AccurateMath.PI, result, solver.getAbsoluteAccuracy());
+ double result = solver.solve(100, f, JdkMath.PI, 4);
+ Assert.assertEquals(JdkMath.PI, result, solver.getAbsoluteAccuracy());
- result = solver.solve(100, f, 3, AccurateMath.PI);
- Assert.assertEquals(AccurateMath.PI, result, solver.getAbsoluteAccuracy());
+ result = solver.solve(100, f, 3, JdkMath.PI);
+ Assert.assertEquals(JdkMath.PI, result, solver.getAbsoluteAccuracy());
- result = solver.solve(100, f, AccurateMath.PI, 4, 3.5);
- Assert.assertEquals(AccurateMath.PI, result, solver.getAbsoluteAccuracy());
+ result = solver.solve(100, f, JdkMath.PI, 4, 3.5);
+ Assert.assertEquals(JdkMath.PI, result, solver.getAbsoluteAccuracy());
- result = solver.solve(100, f, 3, AccurateMath.PI, 3.07);
- Assert.assertEquals(AccurateMath.PI, result, solver.getAbsoluteAccuracy());
+ result = solver.solve(100, f, 3, JdkMath.PI, 3.07);
+ Assert.assertEquals(JdkMath.PI, result, solver.getAbsoluteAccuracy());
}
@Test
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/LaguerreSolverTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/LaguerreSolverTest.java
index 23ee62d..c1ebc37 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/LaguerreSolverTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/LaguerreSolverTest.java
@@ -20,7 +20,7 @@
import org.apache.commons.math4.legacy.analysis.polynomials.PolynomialFunction;
import org.apache.commons.math4.legacy.exception.NoBracketingException;
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.TestUtils;
import org.junit.Assert;
import org.junit.Test;
@@ -52,8 +52,8 @@
LaguerreSolver solver = new LaguerreSolver();
min = 0.0; max = 1.0; expected = 0.25;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
}
@@ -75,14 +75,14 @@
LaguerreSolver solver = new LaguerreSolver();
min = 0.0; max = 2.0; expected = 0.5;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
min = -4.0; max = -1.0; expected = -3.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
}
@@ -104,20 +104,20 @@
LaguerreSolver solver = new LaguerreSolver();
min = -2.0; max = 2.0; expected = -1.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
min = -5.0; max = -2.5; expected = -3.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
min = 3.0; max = 6.0; expected = 4.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
}
@@ -135,11 +135,11 @@
for (Complex expected : new Complex[] { Complex.ofCartesian(0, -2),
Complex.ofCartesian(0, 2),
- Complex.ofCartesian(0.5, 0.5 * AccurateMath.sqrt(3)),
+ Complex.ofCartesian(0.5, 0.5 * JdkMath.sqrt(3)),
Complex.ofCartesian(-1, 0),
- Complex.ofCartesian(0.5, -0.5 * AccurateMath.sqrt(3.0)) }) {
- final double tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected.abs() * solver.getRelativeAccuracy()));
+ Complex.ofCartesian(0.5, -0.5 * JdkMath.sqrt(3.0)) }) {
+ final double tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected.abs() * solver.getRelativeAccuracy()));
TestUtils.assertContains(result, expected, tolerance);
}
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/MullerSolver2Test.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/MullerSolver2Test.java
index 9ba53c0..515036c 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/MullerSolver2Test.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/MullerSolver2Test.java
@@ -22,7 +22,7 @@
import org.apache.commons.math4.legacy.analysis.function.Sin;
import org.apache.commons.math4.legacy.exception.NoBracketingException;
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;
@@ -52,15 +52,15 @@
double result;
double tolerance;
- min = 3.0; max = 4.0; expected = AccurateMath.PI;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ min = 3.0; max = 4.0; expected = JdkMath.PI;
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
min = -1.0; max = 1.5; expected = 0.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
}
@@ -79,20 +79,20 @@
double tolerance;
min = -0.4; max = 0.2; expected = 0.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
min = 0.75; max = 1.5; expected = 1.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
min = -0.9; max = -0.2; expected = -0.5;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
}
@@ -113,20 +113,20 @@
double tolerance;
min = -1.0; max = 2.0; expected = 0.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
min = -20.0; max = 10.0; expected = 0.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
min = -50.0; max = 100.0; expected = 0.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/MullerSolverTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/MullerSolverTest.java
index ba2dcb0..40f26ce 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/MullerSolverTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/MullerSolverTest.java
@@ -22,7 +22,7 @@
import org.apache.commons.math4.legacy.analysis.function.Sin;
import org.apache.commons.math4.legacy.exception.NoBracketingException;
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;
@@ -52,15 +52,15 @@
double result;
double tolerance;
- min = 3.0; max = 4.0; expected = AccurateMath.PI;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ min = 3.0; max = 4.0; expected = JdkMath.PI;
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
min = -1.0; max = 1.5; expected = 0.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
}
@@ -79,20 +79,20 @@
double tolerance;
min = -0.4; max = 0.2; expected = 0.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
min = 0.75; max = 1.5; expected = 1.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
min = -0.9; max = -0.2; expected = -0.5;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
}
@@ -115,20 +115,20 @@
double tolerance;
min = -1.0; max = 2.0; expected = 0.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
min = -20.0; max = 10.0; expected = 0.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
min = -50.0; max = 100.0; expected = 0.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/NewtonRaphsonSolverTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/NewtonRaphsonSolverTest.java
index 9aec41a..066ffc3 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/NewtonRaphsonSolverTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/NewtonRaphsonSolverTest.java
@@ -19,7 +19,7 @@
import org.apache.commons.math4.legacy.analysis.QuinticFunction;
import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
import org.apache.commons.math4.legacy.analysis.function.Sin;
-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;
@@ -37,10 +37,10 @@
NewtonRaphsonSolver solver = new NewtonRaphsonSolver();
result = solver.solve(100, f, 3, 4);
- Assert.assertEquals(result, AccurateMath.PI, solver.getAbsoluteAccuracy());
+ Assert.assertEquals(result, JdkMath.PI, solver.getAbsoluteAccuracy());
result = solver.solve(100, f, 1, 4);
- Assert.assertEquals(result, AccurateMath.PI, solver.getAbsoluteAccuracy());
+ Assert.assertEquals(result, JdkMath.PI, solver.getAbsoluteAccuracy());
Assert.assertTrue(solver.getEvaluations() > 0);
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/RegulaFalsiSolverTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/RegulaFalsiSolverTest.java
index a560fbf..32cf4dd 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/RegulaFalsiSolverTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/RegulaFalsiSolverTest.java
@@ -19,7 +19,7 @@
import org.apache.commons.math4.legacy.analysis.UnivariateFunction;
import org.apache.commons.math4.legacy.exception.ConvergenceException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
import org.junit.Test;
import org.junit.Assert;
@@ -49,7 +49,7 @@
/** {@inheritDoc} */
@Override
public double value(double x) {
- return AccurateMath.exp(x) - AccurateMath.pow(Math.PI, 3.0);
+ return JdkMath.exp(x) - JdkMath.pow(Math.PI, 3.0);
}
};
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/RiddersSolverTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/RiddersSolverTest.java
index e7bf519..f7ead25 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/RiddersSolverTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/RiddersSolverTest.java
@@ -22,7 +22,7 @@
import org.apache.commons.math4.legacy.analysis.function.Sin;
import org.apache.commons.math4.legacy.exception.NoBracketingException;
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;
@@ -50,15 +50,15 @@
double result;
double tolerance;
- min = 3.0; max = 4.0; expected = AccurateMath.PI;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ min = 3.0; max = 4.0; expected = JdkMath.PI;
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
min = -1.0; max = 1.5; expected = 0.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
}
@@ -77,20 +77,20 @@
double tolerance;
min = -0.4; max = 0.2; expected = 0.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
min = 0.75; max = 1.5; expected = 1.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
min = -0.9; max = -0.2; expected = -0.5;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
}
@@ -109,20 +109,20 @@
double tolerance;
min = -1.0; max = 2.0; expected = 0.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
min = -20.0; max = 10.0; expected = 0.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
min = -50.0; max = 100.0; expected = 0.0;
- tolerance = AccurateMath.max(solver.getAbsoluteAccuracy(),
- AccurateMath.abs(expected * solver.getRelativeAccuracy()));
+ tolerance = JdkMath.max(solver.getAbsoluteAccuracy(),
+ JdkMath.abs(expected * solver.getRelativeAccuracy()));
result = solver.solve(100, f, min, max);
Assert.assertEquals(expected, result, tolerance);
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/UnivariateSolverUtilsTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/UnivariateSolverUtilsTest.java
index 4548cd1..6ee0d85 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/UnivariateSolverUtilsTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/analysis/solvers/UnivariateSolverUtilsTest.java
@@ -23,7 +23,7 @@
import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
import org.apache.commons.math4.legacy.exception.NoBracketingException;
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;
@@ -57,7 +57,7 @@
@Test
public void testSolveSin() {
double x = UnivariateSolverUtils.solve(sin, 1.0, 4.0);
- Assert.assertEquals(AccurateMath.PI, x, 1.0e-4);
+ Assert.assertEquals(JdkMath.PI, x, 1.0e-4);
}
@Test(expected=NullArgumentException.class)
@@ -71,7 +71,7 @@
double accuracy = 1.0e-6;
double x = UnivariateSolverUtils.solve(sin, 1.0,
4.0, accuracy);
- Assert.assertEquals(AccurateMath.PI, x, accuracy);
+ Assert.assertEquals(JdkMath.PI, x, accuracy);
}
@Test(expected=MathIllegalArgumentException.class)
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/EmpiricalDistributionTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/EmpiricalDistributionTest.java
index a168e36..82420b1 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/EmpiricalDistributionTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/EmpiricalDistributionTest.java
@@ -34,7 +34,7 @@
import org.apache.commons.math4.legacy.analysis.integration.IterativeLegendreGaussIntegrator;
import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
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;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@@ -366,10 +366,10 @@
*/
private int findBin(double x) {
// Number of bins below x should be trunc(x/10)
- final double nMinus = AccurateMath.floor(x / 10);
- final int bin = (int) AccurateMath.round(nMinus);
+ final double nMinus = JdkMath.floor(x / 10);
+ final int bin = (int) JdkMath.round(nMinus);
// If x falls on a bin boundary, it is in the lower bin
- return AccurateMath.floor(x / 10) == x / 10 ? bin - 1 : bin;
+ return JdkMath.floor(x / 10) == x / 10 ? bin - 1 : bin;
}
/**
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/EnumeratedIntegerDistributionTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/EnumeratedIntegerDistributionTest.java
index ff8257f..0810e8f 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/EnumeratedIntegerDistributionTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/EnumeratedIntegerDistributionTest.java
@@ -22,7 +22,7 @@
import org.apache.commons.math4.legacy.exception.NotANumberException;
import org.apache.commons.math4.legacy.exception.NotFiniteNumberException;
import org.apache.commons.math4.legacy.exception.NotPositiveException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
import org.apache.commons.rng.simple.RandomSource;
import org.junit.Assert;
import org.junit.Test;
@@ -169,7 +169,7 @@
Assert.assertEquals(testDistribution.getMean(),
sum / n, 1e-2);
Assert.assertEquals(testDistribution.getVariance(),
- sumOfSquares / n - AccurateMath.pow(sum / n, 2), 1e-2);
+ sumOfSquares / n - JdkMath.pow(sum / n, 2), 1e-2);
}
@Test
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/EnumeratedRealDistributionTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/EnumeratedRealDistributionTest.java
index db58a66..4d38287 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/EnumeratedRealDistributionTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/EnumeratedRealDistributionTest.java
@@ -27,7 +27,7 @@
import org.apache.commons.math4.legacy.exception.NotANumberException;
import org.apache.commons.math4.legacy.exception.NotFiniteNumberException;
import org.apache.commons.math4.legacy.exception.NotPositiveException;
-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;
import org.apache.commons.rng.UniformRandomProvider;
import org.apache.commons.rng.simple.RandomSource;
@@ -189,7 +189,7 @@
Assert.assertEquals(testDistribution.getMean(),
sum / n, 1e-2);
Assert.assertEquals(testDistribution.getVariance(),
- sumOfSquares / n - AccurateMath.pow(sum / n, 2), 1e-2);
+ sumOfSquares / n - JdkMath.pow(sum / n, 2), 1e-2);
}
@Test
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/IntegerDistributionAbstractTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/IntegerDistributionAbstractTest.java
index fc56539..95f1a42 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/IntegerDistributionAbstractTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/IntegerDistributionAbstractTest.java
@@ -20,7 +20,7 @@
import org.apache.commons.math4.legacy.TestUtils;
import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
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.After;
import org.junit.Assert;
import org.junit.Before;
@@ -99,7 +99,7 @@
final double[] densityTestValues = makeDensityTestValues();
final double[] logDensityTestValues = new double[densityTestValues.length];
for (int i = 0; i < densityTestValues.length; i++) {
- logDensityTestValues[i] = AccurateMath.log(densityTestValues[i]);
+ logDensityTestValues[i] = JdkMath.log(densityTestValues[i]);
}
return logDensityTestValues;
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/RealDistributionAbstractTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/RealDistributionAbstractTest.java
index 116a5d3..b96aff2 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/RealDistributionAbstractTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/distribution/RealDistributionAbstractTest.java
@@ -33,7 +33,7 @@
import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
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.After;
import org.junit.Assert;
import org.junit.Before;
@@ -117,7 +117,7 @@
final double[] densityTestValues = makeDensityTestValues();
final double[] logDensityTestValues = new double[densityTestValues.length];
for (int i = 0; i < densityTestValues.length; i++) {
- logDensityTestValues[i] = AccurateMath.log(densityTestValues[i]);
+ logDensityTestValues[i] = JdkMath.log(densityTestValues[i]);
}
return logDensityTestValues;
}
@@ -285,8 +285,8 @@
(cumulativeTestPoints[i], cumulativeTestPoints[i]), tolerance);
// check that P(a < X <= b) = P(X <= b) - P(X <= a)
- double upper = AccurateMath.max(cumulativeTestPoints[i], cumulativeTestPoints[i -1]);
- double lower = AccurateMath.min(cumulativeTestPoints[i], cumulativeTestPoints[i -1]);
+ double upper = JdkMath.max(cumulativeTestPoints[i], cumulativeTestPoints[i -1]);
+ double lower = JdkMath.min(cumulativeTestPoints[i], cumulativeTestPoints[i -1]);
double diff = distribution.cumulativeProbability(upper) -
distribution.cumulativeProbability(lower);
double direct = distribution.probability(lower, upper);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/field/ExtendedFieldElementAbstractTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/field/ExtendedFieldElementAbstractTest.java
index 3f8deb2..248e878 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/field/ExtendedFieldElementAbstractTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/field/ExtendedFieldElementAbstractTest.java
@@ -24,7 +24,7 @@
import org.apache.commons.rng.simple.RandomSource;
import org.apache.commons.math4.legacy.core.RealFieldElement;
import org.apache.commons.math4.legacy.core.MathArrays;
-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>> {
@@ -115,7 +115,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)));
}
}
}
@@ -124,7 +124,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));
}
}
}
@@ -132,42 +132,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());
}
}
@@ -175,7 +175,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)));
}
}
}
@@ -183,56 +183,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());
}
}
@@ -240,7 +240,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)));
}
}
}
@@ -251,10 +251,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));
}
}
}
@@ -264,7 +264,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)));
}
}
}
@@ -273,7 +273,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));
}
}
}
@@ -282,7 +282,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));
}
}
}
@@ -290,77 +290,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());
}
}
@@ -368,7 +368,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)));
}
}
}
@@ -377,7 +377,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));
}
}
}
@@ -386,7 +386,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));
}
}
}
@@ -516,7 +516,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/src/test/java/org/apache/commons/math4/legacy/filter/KalmanFilterTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/filter/KalmanFilterTest.java
index 60ee698..77585e0 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/filter/KalmanFilterTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/filter/KalmanFilterTest.java
@@ -28,7 +28,7 @@
import org.apache.commons.math4.legacy.linear.MatrixUtils;
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;
import org.junit.Assert;
import org.junit.Test;
@@ -146,7 +146,7 @@
filter.correct(z);
// state estimate shouldn't be larger than measurement noise
- double diff = AccurateMath.abs(constantValue - filter.getStateEstimation()[0]);
+ double diff = JdkMath.abs(constantValue - filter.getStateEstimation()[0]);
// System.out.println(diff);
Assert.assertTrue(Precision.compareTo(diff, measurementNoise, 1e-6) < 0);
}
@@ -174,7 +174,7 @@
// B = [ dt^2/2 ]
// [ dt ]
RealMatrix B = new Array2DRowRealMatrix(
- new double[][] { { AccurateMath.pow(dt, 2d) / 2d }, { dt } });
+ new double[][] { { JdkMath.pow(dt, 2d) / 2d }, { dt } });
// H = [ 1 0 ]
RealMatrix H = new Array2DRowRealMatrix(new double[][] { { 1d, 0d } });
@@ -183,12 +183,12 @@
RealVector x = new ArrayRealVector(new double[] { 0, 0 });
RealMatrix tmp = new Array2DRowRealMatrix(
- new double[][] { { AccurateMath.pow(dt, 4d) / 4d, AccurateMath.pow(dt, 3d) / 2d },
- { AccurateMath.pow(dt, 3d) / 2d, AccurateMath.pow(dt, 2d) } });
+ new double[][] { { JdkMath.pow(dt, 4d) / 4d, JdkMath.pow(dt, 3d) / 2d },
+ { JdkMath.pow(dt, 3d) / 2d, JdkMath.pow(dt, 2d) } });
// Q = [ dt^4/4 dt^3/2 ]
// [ dt^3/2 dt^2 ]
- RealMatrix Q = tmp.scalarMultiply(AccurateMath.pow(accelNoise, 2));
+ RealMatrix Q = tmp.scalarMultiply(JdkMath.pow(accelNoise, 2));
// P0 = [ 1 1 ]
// [ 1 1 ]
@@ -196,7 +196,7 @@
// R = [ measurementNoise^2 ]
RealMatrix R = new Array2DRowRealMatrix(
- new double[] { AccurateMath.pow(measurementNoise, 2) });
+ new double[] { JdkMath.pow(measurementNoise, 2) });
// constant control input, increase velocity by 0.1 m/s per cycle
RealVector u = new ArrayRealVector(new double[] { 0.1d });
@@ -217,7 +217,7 @@
final ContinuousSampler rand = createGaussianSampler(0, 1);
RealVector tmpPNoise = new ArrayRealVector(
- new double[] { AccurateMath.pow(dt, 2d) / 2d, dt });
+ new double[] { JdkMath.pow(dt, 2d) / 2d, dt });
// iterate 60 steps
for (int i = 0; i < 60; i++) {
@@ -238,7 +238,7 @@
filter.correct(z);
// state estimate shouldn't be larger than the measurement noise
- double diff = AccurateMath.abs(x.getEntry(0) - filter.getStateEstimation()[0]);
+ double diff = JdkMath.abs(x.getEntry(0) - filter.getStateEstimation()[0]);
Assert.assertTrue(Precision.compareTo(diff, measurementNoise, 1e-6) < 0);
}
@@ -262,10 +262,10 @@
public Cannonball(double timeslice, double angle, double initialVelocity) {
this.timeslice = timeslice;
- final double angleInRadians = AccurateMath.toRadians(angle);
+ final double angleInRadians = JdkMath.toRadians(angle);
this.velocity = new double[] {
- initialVelocity * AccurateMath.cos(angleInRadians),
- initialVelocity * AccurateMath.sin(angleInRadians)
+ initialVelocity * JdkMath.cos(angleInRadians),
+ initialVelocity * JdkMath.sin(angleInRadians)
};
this.location = new double[] { 0, 0 };
@@ -409,7 +409,7 @@
filter.correct(new double[] { nx, 0, ny, 0 } );
// state estimate shouldn't be larger than the measurement noise
- double diff = AccurateMath.abs(cannonball.getY() - filter.getStateEstimation()[2]);
+ double diff = JdkMath.abs(cannonball.getY() - filter.getStateEstimation()[2]);
Assert.assertTrue(Precision.compareTo(diff, measurementNoise, 1e-6) < 0);
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/HarmonicCurveFitterTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/HarmonicCurveFitterTest.java
index 503d059..ef0c907 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/HarmonicCurveFitterTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/HarmonicCurveFitterTest.java
@@ -24,7 +24,7 @@
import org.apache.commons.math4.legacy.analysis.function.HarmonicOscillator;
import org.apache.commons.math4.legacy.exception.MathIllegalStateException;
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;
@@ -57,7 +57,7 @@
final HarmonicOscillator ff = new HarmonicOscillator(fitted[0], fitted[1], fitted[2]);
for (double x = -1.0; x < 1.0; x += 0.01) {
- Assert.assertTrue(AccurateMath.abs(f.value(x) - ff.value(x)) < 1e-13);
+ Assert.assertTrue(JdkMath.abs(f.value(x) - ff.value(x)) < 1e-13);
}
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/PolynomialCurveFitterTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/PolynomialCurveFitterTest.java
index 79ec3cf..1f31d87 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/PolynomialCurveFitterTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/PolynomialCurveFitterTest.java
@@ -23,7 +23,7 @@
import org.apache.commons.statistics.distribution.ContinuousDistribution;
import org.apache.commons.statistics.distribution.UniformContinuousDistribution;
import org.apache.commons.math4.legacy.exception.ConvergenceException;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
import org.apache.commons.rng.simple.RandomSource;
import org.junit.Assert;
import org.junit.Test;
@@ -69,8 +69,8 @@
final PolynomialFunction fitted = new PolynomialFunction(fitter.fit(obs.toList()));
for (double x = -1.0; x < 1.0; x += 0.01) {
- final double error = AccurateMath.abs(p.value(x) - fitted.value(x)) /
- (1.0 + AccurateMath.abs(p.value(x)));
+ final double error = JdkMath.abs(p.value(x) - fitted.value(x)) /
+ (1.0 + JdkMath.abs(p.value(x)));
Assert.assertEquals(0.0, error, 1.0e-6);
}
}
@@ -92,10 +92,10 @@
final PolynomialFunction fitted = new PolynomialFunction(fitter.fit(obs.toList()));
for (double x = -1.0; x < 1.0; x += 0.01) {
- final double error = AccurateMath.abs(p.value(x) - fitted.value(x)) /
- (1.0 + AccurateMath.abs(p.value(x)));
- maxError = AccurateMath.max(maxError, error);
- Assert.assertTrue(AccurateMath.abs(error) < 0.1);
+ final double error = JdkMath.abs(p.value(x) - fitted.value(x)) /
+ (1.0 + JdkMath.abs(p.value(x)));
+ maxError = JdkMath.max(maxError, error);
+ Assert.assertTrue(JdkMath.abs(error) < 0.1);
}
}
Assert.assertTrue(maxError > 0.01);
@@ -123,10 +123,10 @@
final PolynomialFunction fitted = new PolynomialFunction(fitter.fit(obs.toList()));
for (double x = -1.0; x < 1.0; x += 0.01) {
- final double error = AccurateMath.abs(p.value(x) - fitted.value(x)) /
- (1.0 + AccurateMath.abs(p.value(x)));
- maxError = AccurateMath.max(maxError, error);
- Assert.assertTrue(AccurateMath.abs(error) < 0.01);
+ final double error = JdkMath.abs(p.value(x) - fitted.value(x)) /
+ (1.0 + JdkMath.abs(p.value(x)));
+ maxError = JdkMath.max(maxError, error);
+ Assert.assertTrue(JdkMath.abs(error) < 0.01);
}
}
Assert.assertTrue(maxError > 0.001);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/AbstractLeastSquaresOptimizerAbstractTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/AbstractLeastSquaresOptimizerAbstractTest.java
index 6f1c35c..d601c86 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/AbstractLeastSquaresOptimizerAbstractTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/AbstractLeastSquaresOptimizerAbstractTest.java
@@ -31,7 +31,7 @@
import org.apache.commons.math4.legacy.linear.RealVector;
import org.apache.commons.math4.legacy.optim.ConvergenceChecker;
import org.apache.commons.math4.legacy.optim.SimpleVectorValueChecker;
-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;
import org.junit.Assert;
import org.junit.Test;
@@ -132,12 +132,12 @@
return new Pair<RealVector, RealMatrix>(
new ArrayRealVector(
new double[]{
- AccurateMath.pow(point.getEntry(0), 4)
+ JdkMath.pow(point.getEntry(0), 4)
},
false),
new Array2DRowRealMatrix(
new double[][]{
- {0.25 * AccurateMath.pow(point.getEntry(0), 3)}
+ {0.25 * JdkMath.pow(point.getEntry(0), 3)}
},
false)
);
@@ -406,7 +406,7 @@
Assert.assertTrue(optimum.getEvaluations() < 10);
double rms = optimum.getRMS();
- Assert.assertEquals(1.768262623567235, AccurateMath.sqrt(circle.getN()) * rms, TOL);
+ Assert.assertEquals(1.768262623567235, JdkMath.sqrt(circle.getN()) * rms, TOL);
Vector2D center = Vector2D.of(optimum.getPoint().getEntry(0), optimum.getPoint().getEntry(1));
Assert.assertEquals(69.96016176931406, circle.getRadius(center), 1e-6);
@@ -421,8 +421,8 @@
// add perfect measurements and check formal errors are reduced
double r = circle.getRadius(center);
- for (double d = 0; d < 2 * AccurateMath.PI; d += 0.01) {
- circle.addPoint(center.getX() + r * AccurateMath.cos(d), center.getY() + r * AccurateMath.sin(d));
+ for (double d = 0; d < 2 * JdkMath.PI; d += 0.01) {
+ circle.addPoint(center.getX() + r * JdkMath.cos(d), center.getY() + r * JdkMath.sin(d));
}
double[] weights = new double[circle.getN()];
@@ -519,7 +519,7 @@
final RealVector actual = optimum.getPoint();
for (int i = 0; i < actual.getDimension(); i++) {
double expected = dataset.getParameter(i);
- double delta = AccurateMath.abs(errParams * expected);
+ double delta = JdkMath.abs(errParams * expected);
Assert.assertEquals(dataset.getName() + ", param #" + i,
expected, actual.getEntry(i), delta);
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/BevingtonProblem.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/BevingtonProblem.java
index b23936f..0de1a80 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/BevingtonProblem.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/BevingtonProblem.java
@@ -18,7 +18,7 @@
import org.apache.commons.math4.legacy.analysis.MultivariateMatrixFunction;
import org.apache.commons.math4.legacy.analysis.MultivariateVectorFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
import java.util.ArrayList;
import java.util.List;
@@ -45,8 +45,8 @@
for (int i = 0; i < values.length; ++i) {
final double t = time.get(i);
values[i] = params[0] +
- params[1] * AccurateMath.exp(-t / params[3]) +
- params[2] * AccurateMath.exp(-t / params[4]);
+ params[1] * JdkMath.exp(-t / params[3]) +
+ params[2] * JdkMath.exp(-t / params[4]);
}
return values;
}
@@ -67,10 +67,10 @@
final double p4 = params[4];
final double tOp3 = t / p3;
final double tOp4 = t / p4;
- jacobian[i][1] = AccurateMath.exp(-tOp3);
- jacobian[i][2] = AccurateMath.exp(-tOp4);
- jacobian[i][3] = params[1] * AccurateMath.exp(-tOp3) * tOp3 / p3;
- jacobian[i][4] = params[2] * AccurateMath.exp(-tOp4) * tOp4 / p4;
+ jacobian[i][1] = JdkMath.exp(-tOp3);
+ jacobian[i][2] = JdkMath.exp(-tOp4);
+ jacobian[i][3] = params[1] * JdkMath.exp(-tOp3) * tOp3 / p3;
+ jacobian[i][4] = params[2] * JdkMath.exp(-tOp4) * tOp4 / p4;
}
return jacobian;
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/CircleProblem.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/CircleProblem.java
index 9664c7a..bab9e1b 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/CircleProblem.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/CircleProblem.java
@@ -20,7 +20,7 @@
import org.apache.commons.math4.legacy.analysis.MultivariateMatrixFunction;
import org.apache.commons.math4.legacy.analysis.MultivariateVectorFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
/**
* Class that models a circle.
@@ -125,8 +125,8 @@
// current point (using a resolution of 100 points along the
// circumference).
for (double theta = 0; theta <= twopi; theta += deltaTheta) {
- final double currentX = cx + r * AccurateMath.cos(theta);
- final double currentY = cy + r * AccurateMath.sin(theta);
+ final double currentX = cx + r * JdkMath.cos(theta);
+ final double currentY = cy + r * JdkMath.sin(theta);
final double dX = currentX - px;
final double dY = currentY - py;
final double d = dX * dX + dY * dY;
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/DifferentiatorVectorMultivariateJacobianFunctionTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/DifferentiatorVectorMultivariateJacobianFunctionTest.java
index 18b1e61..cbf8e7a 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/DifferentiatorVectorMultivariateJacobianFunctionTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/DifferentiatorVectorMultivariateJacobianFunctionTest.java
@@ -22,7 +22,7 @@
import org.apache.commons.math4.legacy.linear.RealMatrix;
import org.apache.commons.math4.legacy.linear.RealVector;
import org.apache.commons.math4.legacy.optim.SimpleVectorValueChecker;
-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;
@@ -80,7 +80,7 @@
// Check that the automatic solution is within the reference error range.
for (int i = 0; i < numParams; i++) {
- final double error = AccurateMath.sqrt(analyticalCovarianceMatrix.getEntry(i, i));
+ final double error = JdkMath.sqrt(analyticalCovarianceMatrix.getEntry(i, i));
Assert.assertEquals("Parameter " + i, analyticalSolution.getEntry(i), automaticSolution.getEntry(i), error);
}
@@ -91,7 +91,7 @@
Assert.assertEquals("Covariance matrix [" + i + "][" + j + "]",
analyticalCovarianceMatrix.getEntry(i, j),
automaticCovarianceMatrix.getEntry(i, j),
- AccurateMath.abs(0.01 * analyticalCovarianceMatrix.getEntry(i, j)));
+ JdkMath.abs(0.01 * analyticalCovarianceMatrix.getEntry(i, j)));
}
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/EvaluationTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/EvaluationTest.java
index 71fbe50..4836ac7 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/EvaluationTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/EvaluationTest.java
@@ -27,7 +27,7 @@
import org.apache.commons.math4.legacy.linear.RealMatrix;
import org.apache.commons.math4.legacy.linear.RealVector;
import org.apache.commons.math4.legacy.linear.SingularMatrixException;
-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;
import org.apache.commons.numbers.core.Precision;
import org.junit.Assert;
@@ -112,14 +112,14 @@
//action
TestUtils.assertEquals(
"covariance",
- evaluation.getCovariances(AccurateMath.nextAfter(1e-4, 0.0)),
+ evaluation.getCovariances(JdkMath.nextAfter(1e-4, 0.0)),
MatrixUtils.createRealMatrix(new double[][]{{1, 0}, {0, 1e4}}),
Precision.EPSILON
);
//singularity fail
try {
- evaluation.getCovariances(AccurateMath.nextAfter(1e-4, 1.0));
+ evaluation.getCovariances(JdkMath.nextAfter(1e-4, 1.0));
Assert.fail("Expected Exception");
} catch (SingularMatrixException e) {
//expected
@@ -183,7 +183,7 @@
final LeastSquaresProblem lsp = builder(dataset).build();
- final double expected = AccurateMath.sqrt(dataset.getResidualSumOfSquares() /
+ final double expected = JdkMath.sqrt(dataset.getResidualSumOfSquares() /
dataset.getNumObservations());
final double actual = lsp.evaluate(lsp.getStart()).getRMS();
Assert.assertEquals(dataset.getName(), expected, actual, 1e-11 * expected);
@@ -203,7 +203,7 @@
final RealVector sig = evaluation.getSigma(1e-14);
final int dof = lsp.getObservationSize() - lsp.getParameterSize();
for (int i = 0; i < sig.getDimension(); i++) {
- final double actual = AccurateMath.sqrt(cost * cost / dof) * sig.getEntry(i);
+ final double actual = JdkMath.sqrt(cost * cost / dof) * sig.getEntry(i);
Assert.assertEquals(dataset.getName() + ", parameter #" + i,
expected[i], actual, 1e-6 * expected[i]);
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/EvaluationTestValidation.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/EvaluationTestValidation.java
index 641962b..e50ebd2 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/EvaluationTestValidation.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/EvaluationTestValidation.java
@@ -21,7 +21,7 @@
import org.apache.commons.math4.legacy.linear.RealVector;
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;
import org.junit.Assert;
import org.junit.Test;
@@ -227,7 +227,7 @@
// Monte-Carlo (generates a grid of parameters).
final int mcRepeat = MONTE_CARLO_RUNS;
- final int gridSize = (int) AccurateMath.sqrt(mcRepeat);
+ final int gridSize = (int) JdkMath.sqrt(mcRepeat);
// Parameters found for each of Monte-Carlo run.
// Index 0 = slope
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/GaussNewtonOptimizerWithSVDTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/GaussNewtonOptimizerWithSVDTest.java
index 2df8fb8..79810c7 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/GaussNewtonOptimizerWithSVDTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/GaussNewtonOptimizerWithSVDTest.java
@@ -26,7 +26,7 @@
import org.apache.commons.math4.legacy.fitting.leastsquares.GaussNewtonOptimizer.Decomposition;
import org.apache.commons.math4.legacy.fitting.leastsquares.LeastSquaresOptimizer.Optimum;
import org.apache.commons.math4.legacy.optim.SimpleVectorValueChecker;
-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;
@@ -141,7 +141,7 @@
Plane span = Planes.fromPoints(Vector3D.ZERO, Vector3D.of(1, 2, -3), Vector3D.of(2, 1, 0),
Precision.doubleEquivalenceOfEpsilon(TOL));
- double expected = AccurateMath.abs(span.offset(Vector3D.of(1, 1, 1)));
+ double expected = JdkMath.abs(span.offset(Vector3D.of(1, 1, 1)));
double actual = optimum.getResiduals().getNorm();
//verify
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/LevenbergMarquardtOptimizerTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/LevenbergMarquardtOptimizerTest.java
index cf610c3..aedeed8 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/LevenbergMarquardtOptimizerTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/LevenbergMarquardtOptimizerTest.java
@@ -27,7 +27,7 @@
import org.apache.commons.math4.legacy.linear.RealVector;
import org.apache.commons.math4.legacy.linear.SingularMatrixException;
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.numbers.core.Precision;
import org.junit.Assert;
import org.junit.Test;
@@ -85,7 +85,7 @@
problem.getBuilder().maxIterations(20).build());
//TODO check that it is a bad fit? Why the extra conditions?
- Assert.assertTrue(AccurateMath.sqrt(problem.getTarget().length) * optimum.getRMS() > 0.6);
+ Assert.assertTrue(JdkMath.sqrt(problem.getTarget().length) * optimum.getRMS() > 0.6);
optimum.getCovariances(1.5e-14);
@@ -209,7 +209,7 @@
// Check that the computed solution is within the reference error range.
for (int i = 0; i < numParams; i++) {
- final double error = AccurateMath.sqrt(expectedCovarMatrix[i][i]);
+ final double error = JdkMath.sqrt(expectedCovarMatrix[i][i]);
Assert.assertEquals("Parameter " + i, expectedSolution[i], solution.getEntry(i), error);
}
@@ -220,7 +220,7 @@
Assert.assertEquals("Covariance matrix [" + i + "][" + j + "]",
expectedCovarMatrix[i][j],
covarMatrix.getEntry(i, j),
- AccurateMath.abs(0.1 * expectedCovarMatrix[i][j]));
+ JdkMath.abs(0.1 * expectedCovarMatrix[i][j]));
}
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/MinpackTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/MinpackTest.java
index 58191a7..2eb7d18 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/MinpackTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/MinpackTest.java
@@ -24,7 +24,7 @@
import org.apache.commons.math4.legacy.exception.TooManyEvaluationsException;
import org.apache.commons.math4.legacy.fitting.leastsquares.LeastSquaresOptimizer.Optimum;
import org.apache.commons.math4.legacy.linear.DiagonalMatrix;
-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;
@@ -117,11 +117,11 @@
@Test
public void testMinpackRosenbrok() {
minpackTest(new RosenbrockFunction(new double[] { -1.2, 1.0 },
- AccurateMath.sqrt(24.2)), false);
+ JdkMath.sqrt(24.2)), false);
minpackTest(new RosenbrockFunction(new double[] { -12.0, 10.0 },
- AccurateMath.sqrt(1795769.0)), false);
+ JdkMath.sqrt(1795769.0)), false);
minpackTest(new RosenbrockFunction(new double[] { -120.0, 100.0 },
- 11.0 * AccurateMath.sqrt(169000121.0)), false);
+ 11.0 * JdkMath.sqrt(169000121.0)), false);
}
@Test
@@ -498,7 +498,7 @@
private void minpackTest(MinpackFunction function, boolean exceptionExpected) {
final double tol = 2.22044604926e-16;
- final double sqrtTol = AccurateMath.sqrt(tol);
+ final double sqrtTol = JdkMath.sqrt(tol);
LevenbergMarquardtOptimizer optimizer = new LevenbergMarquardtOptimizer()
.withCostRelativeTolerance(sqrtTol)
@@ -577,7 +577,7 @@
public void checkTheoreticalMinCost(double rms) {
double threshold = costAccuracy * (1.0 + theoreticalMinCost);
- Assert.assertEquals(theoreticalMinCost, AccurateMath.sqrt(m) * rms, threshold);
+ Assert.assertEquals(theoreticalMinCost, JdkMath.sqrt(m) * rms, threshold);
}
public void checkTheoreticalMinParams(double[] params) {
@@ -585,7 +585,7 @@
for (int i = 0; i < theoreticalMinParams.length; ++i) {
double mi = theoreticalMinParams[i];
double vi = params[i];
- Assert.assertEquals(mi, vi, paramsAccuracy * (1.0 + AccurateMath.abs(mi)));
+ Assert.assertEquals(mi, vi, paramsAccuracy * (1.0 + JdkMath.abs(mi)));
}
}
}
@@ -688,7 +688,7 @@
LinearRank1ZeroColsAndRowsFunction(int m, int n, double x0) {
super(m, buildArray(n, x0),
- AccurateMath.sqrt((m * (m + 3) - 6) / (2.0 * (2 * m - 3))),
+ JdkMath.sqrt((m * (m + 3) - 6) / (2.0 * (2 * m - 3))),
null);
}
@@ -758,7 +758,7 @@
double x2 = variables[1];
double tmpSquare = x1 * x1 + x2 * x2;
double tmp1 = twoPi * tmpSquare;
- double tmp2 = AccurateMath.sqrt(tmpSquare);
+ double tmp2 = JdkMath.sqrt(tmpSquare);
return new double[][] {
{ 100 * x2 / tmp1, -100 * x1 / tmp1, 10 },
{ 10 * x1 / tmp2, 10 * x2 / tmp2, 0 },
@@ -775,12 +775,12 @@
if (x1 == 0) {
tmp1 = (x2 >= 0) ? 0.25 : -0.25;
} else {
- tmp1 = AccurateMath.atan(x2 / x1) / twoPi;
+ tmp1 = JdkMath.atan(x2 / x1) / twoPi;
if (x1 < 0) {
tmp1 += 0.5;
}
}
- double tmp2 = AccurateMath.sqrt(x1 * x1 + x2 * x2);
+ double tmp2 = JdkMath.sqrt(x1 * x1 + x2 * x2);
return new double[] {
10.0 * (x3 - 10 * tmp1),
10.0 * (tmp2 - 1),
@@ -788,7 +788,7 @@
};
}
- private static final double twoPi = 2.0 * AccurateMath.PI;
+ private static final double twoPi = 2.0 * JdkMath.PI;
}
private static class PowellSingularFunction extends MinpackFunction {
@@ -826,8 +826,8 @@
};
}
- private static final double sqrt5 = AccurateMath.sqrt( 5.0);
- private static final double sqrt10 = AccurateMath.sqrt(10.0);
+ private static final double sqrt5 = JdkMath.sqrt( 5.0);
+ private static final double sqrt10 = JdkMath.sqrt(10.0);
}
private static class FreudensteinRothFunction extends MinpackFunction {
@@ -986,7 +986,7 @@
for (int i = 0; i < m; ++i) {
double temp = 5.0 * (i + 1) + 45.0 + x3;
double tmp1 = x2 / temp;
- double tmp2 = AccurateMath.exp(tmp1);
+ double tmp2 = JdkMath.exp(tmp1);
double tmp3 = x1 * tmp2 / temp;
jacobian[i] = new double[] { tmp2, tmp3, -tmp1 * tmp3 };
}
@@ -1000,7 +1000,7 @@
double x3 = variables[2];
double[] f = new double[m];
for (int i = 0; i < m; ++i) {
- f[i] = x1 * AccurateMath.exp(x2 / (5.0 * (i + 1) + 45.0 + x3)) - y[i];
+ f[i] = x1 * JdkMath.exp(x2 / (5.0 * (i + 1) + 45.0 + x3)) - y[i];
}
return f;
}
@@ -1099,9 +1099,9 @@
for (int i = 0; i < m; ++i) {
double tmp = (i + 1) / 10.0;
jacobian[i] = new double[] {
- -tmp * AccurateMath.exp(-tmp * x1),
- tmp * AccurateMath.exp(-tmp * x2),
- AccurateMath.exp(-i - 1) - AccurateMath.exp(-tmp)
+ -tmp * JdkMath.exp(-tmp * x1),
+ tmp * JdkMath.exp(-tmp * x2),
+ JdkMath.exp(-i - 1) - JdkMath.exp(-tmp)
};
}
return jacobian;
@@ -1115,8 +1115,8 @@
double[] f = new double[m];
for (int i = 0; i < m; ++i) {
double tmp = (i + 1) / 10.0;
- f[i] = AccurateMath.exp(-tmp * x1) - AccurateMath.exp(-tmp * x2)
- + (AccurateMath.exp(-i - 1) - AccurateMath.exp(-tmp)) * x3;
+ f[i] = JdkMath.exp(-tmp * x1) - JdkMath.exp(-tmp * x2)
+ + (JdkMath.exp(-i - 1) - JdkMath.exp(-tmp)) * x3;
}
return f;
}
@@ -1139,7 +1139,7 @@
double[][] jacobian = new double[m][];
for (int i = 0; i < m; ++i) {
double t = i + 1;
- jacobian[i] = new double[] { -t * AccurateMath.exp(t * x1), -t * AccurateMath.exp(t * x2) };
+ jacobian[i] = new double[] { -t * JdkMath.exp(t * x1), -t * JdkMath.exp(t * x2) };
}
return jacobian;
}
@@ -1151,7 +1151,7 @@
double[] f = new double[m];
for (int i = 0; i < m; ++i) {
double temp = i + 1;
- f[i] = 2 + 2 * temp - AccurateMath.exp(temp * x1) - AccurateMath.exp(temp * x2);
+ f[i] = 2 + 2 * temp - JdkMath.exp(temp * x1) - JdkMath.exp(temp * x2);
}
return f;
}
@@ -1177,9 +1177,9 @@
double[][] jacobian = new double[m][];
for (int i = 0; i < m; ++i) {
double temp = (i + 1) / 5.0;
- double ti = AccurateMath.sin(temp);
- double tmp1 = x1 + temp * x2 - AccurateMath.exp(temp);
- double tmp2 = x3 + ti * x4 - AccurateMath.cos(temp);
+ double ti = JdkMath.sin(temp);
+ double tmp1 = x1 + temp * x2 - JdkMath.exp(temp);
+ double tmp2 = x3 + ti * x4 - JdkMath.cos(temp);
jacobian[i] = new double[] {
2 * tmp1, 2 * temp * tmp1, 2 * tmp2, 2 * ti * tmp2
};
@@ -1196,8 +1196,8 @@
double[] f = new double[m];
for (int i = 0; i < m; ++i) {
double temp = (i + 1) / 5.0;
- double tmp1 = x1 + temp * x2 - AccurateMath.exp(temp);
- double tmp2 = x3 + AccurateMath.sin(temp) * x4 - AccurateMath.cos(temp);
+ double tmp1 = x1 + temp * x2 - JdkMath.exp(temp);
+ double tmp2 = x3 + JdkMath.sin(temp) * x4 - JdkMath.cos(temp);
f[i] = tmp1 * tmp1 + tmp2 * tmp2;
}
return f;
@@ -1360,8 +1360,8 @@
double[][] jacobian = new double[m][];
for (int i = 0; i < m; ++i) {
double temp = 10.0 * i;
- double tmp1 = AccurateMath.exp(-temp * x4);
- double tmp2 = AccurateMath.exp(-temp * x5);
+ double tmp1 = JdkMath.exp(-temp * x4);
+ double tmp2 = JdkMath.exp(-temp * x5);
jacobian[i] = new double[] {
-1, -tmp1, -tmp2, temp * x2 * tmp1, temp * x3 * tmp2
};
@@ -1379,8 +1379,8 @@
double[] f = new double[m];
for (int i = 0; i < m; ++i) {
double temp = 10.0 * i;
- double tmp1 = AccurateMath.exp(-temp * x4);
- double tmp2 = AccurateMath.exp(-temp * x5);
+ double tmp1 = JdkMath.exp(-temp * x4);
+ double tmp2 = JdkMath.exp(-temp * x5);
f[i] = y[i] - (x1 + x2 * tmp1 + x3 * tmp2);
}
return f;
@@ -1419,10 +1419,10 @@
double[][] jacobian = new double[m][];
for (int i = 0; i < m; ++i) {
double temp = i / 10.0;
- double tmp1 = AccurateMath.exp(-x05 * temp);
- double tmp2 = AccurateMath.exp(-x06 * (temp - x09) * (temp - x09));
- double tmp3 = AccurateMath.exp(-x07 * (temp - x10) * (temp - x10));
- double tmp4 = AccurateMath.exp(-x08 * (temp - x11) * (temp - x11));
+ double tmp1 = JdkMath.exp(-x05 * temp);
+ double tmp2 = JdkMath.exp(-x06 * (temp - x09) * (temp - x09));
+ double tmp3 = JdkMath.exp(-x07 * (temp - x10) * (temp - x10));
+ double tmp4 = JdkMath.exp(-x08 * (temp - x11) * (temp - x11));
jacobian[i] = new double[] {
-tmp1,
-tmp2,
@@ -1456,10 +1456,10 @@
double[] f = new double[m];
for (int i = 0; i < m; ++i) {
double temp = i / 10.0;
- double tmp1 = AccurateMath.exp(-x05 * temp);
- double tmp2 = AccurateMath.exp(-x06 * (temp - x09) * (temp - x09));
- double tmp3 = AccurateMath.exp(-x07 * (temp - x10) * (temp - x10));
- double tmp4 = AccurateMath.exp(-x08 * (temp - x11) * (temp - x11));
+ double tmp1 = JdkMath.exp(-x05 * temp);
+ double tmp2 = JdkMath.exp(-x06 * (temp - x09) * (temp - x09));
+ double tmp3 = JdkMath.exp(-x07 * (temp - x10) * (temp - x10));
+ double tmp4 = JdkMath.exp(-x08 * (temp - x11) * (temp - x11));
f[i] = y[i] - (x01 * tmp1 + x02 * tmp2 + x03 * tmp3 + x04 * tmp4);
}
return f;
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/RandomCirclePointGenerator.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/RandomCirclePointGenerator.java
index 5437544..d85921c 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/RandomCirclePointGenerator.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/RandomCirclePointGenerator.java
@@ -22,7 +22,7 @@
import org.apache.commons.statistics.distribution.UniformContinuousDistribution;
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;
/**
* Factory for generating a cloud of points that approximate a circle.
@@ -77,8 +77,8 @@
*/
private Vector2D create() {
final double t = tP.sample();
- final double pX = cX.sample() + radius * AccurateMath.cos(t);
- final double pY = cY.sample() + radius * AccurateMath.sin(t);
+ final double pX = cX.sample() + radius * JdkMath.cos(t);
+ final double pY = cY.sample() + radius * JdkMath.sin(t);
return Vector2D.of(pX, pY);
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/StatisticalReferenceDatasetFactory.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/StatisticalReferenceDatasetFactory.java
index 0826106..7bec349 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/StatisticalReferenceDatasetFactory.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/fitting/leastsquares/StatisticalReferenceDatasetFactory.java
@@ -21,7 +21,7 @@
import java.io.InputStream;
import java.io.InputStreamReader;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
/**
* A factory to create instances of {@link StatisticalReferenceDataset} from
@@ -130,8 +130,8 @@
@Override
public double getModelValue(final double x, final double[] a) {
- return a[0] + a[1] * AccurateMath.exp(-a[3] * x) + a[2] *
- AccurateMath.exp(-a[4] * x);
+ return a[0] + a[1] * JdkMath.exp(-a[3] * x) + a[2] *
+ JdkMath.exp(-a[4] * x);
}
@Override
@@ -139,8 +139,8 @@
final double[] a) {
final double[] dy = new double[5];
dy[0] = 1.0;
- dy[1] = AccurateMath.exp(-x * a[3]);
- dy[2] = AccurateMath.exp(-x * a[4]);
+ dy[1] = JdkMath.exp(-x * a[3]);
+ dy[2] = JdkMath.exp(-x * a[4]);
dy[3] = -x * a[1] * dy[1];
dy[4] = -x * a[2] * dy[2];
return dy;
@@ -163,18 +163,18 @@
@Override
public double getModelValue(final double x, final double[] a) {
System.out.println(a[0]+", "+a[1]+", "+a[2]+", "+a[3]+", "+a[4]+", "+a[5]);
- return a[0] * AccurateMath.exp(-a[3] * x) +
- a[1] * AccurateMath.exp(-a[4] * x) +
- a[2] * AccurateMath.exp(-a[5] * x);
+ return a[0] * JdkMath.exp(-a[3] * x) +
+ a[1] * JdkMath.exp(-a[4] * x) +
+ a[2] * JdkMath.exp(-a[5] * x);
}
@Override
public double[] getModelDerivatives(final double x,
final double[] a) {
final double[] dy = new double[6];
- dy[0] = AccurateMath.exp(-x * a[3]);
- dy[1] = AccurateMath.exp(-x * a[4]);
- dy[2] = AccurateMath.exp(-x * a[5]);
+ dy[0] = JdkMath.exp(-x * a[3]);
+ dy[1] = JdkMath.exp(-x * a[4]);
+ dy[2] = JdkMath.exp(-x * a[5]);
dy[3] = -x * a[0] * dy[0];
dy[4] = -x * a[1] * dy[1];
dy[5] = -x * a[2] * dy[2];
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/genetics/FixedElapsedTimeTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/genetics/FixedElapsedTimeTest.java
index 635c45c..be260ab 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/genetics/FixedElapsedTimeTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/genetics/FixedElapsedTimeTest.java
@@ -19,7 +19,7 @@
import java.util.Iterator;
import java.util.concurrent.TimeUnit;
-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;
@@ -73,7 +73,7 @@
final long end = System.nanoTime();
final long elapsedTime = end - start;
- final long diff = AccurateMath.abs(elapsedTime - TimeUnit.SECONDS.toNanos(duration));
+ final long diff = JdkMath.abs(elapsedTime - TimeUnit.SECONDS.toNanos(duration));
Assert.assertTrue(diff < TimeUnit.MILLISECONDS.toNanos(100));
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/genetics/GeneticAlgorithmTestPermutations.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/genetics/GeneticAlgorithmTestPermutations.java
index ac3a1c7..2097c41 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/genetics/GeneticAlgorithmTestPermutations.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/genetics/GeneticAlgorithmTestPermutations.java
@@ -20,7 +20,7 @@
import java.util.ArrayList;
import java.util.List;
-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;
@@ -117,7 +117,7 @@
int value = decoded.get(i);
if (value != i) {
// bad position found
- res += AccurateMath.abs(value - i);
+ res += JdkMath.abs(value - i);
}
}
// the most fitted chromosome is the one with minimal error
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/Array2DRowRealMatrixTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/Array2DRowRealMatrixTest.java
index c9cb97b..5a7f971 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/Array2DRowRealMatrixTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/Array2DRowRealMatrixTest.java
@@ -26,7 +26,7 @@
import org.apache.commons.math4.legacy.exception.NullArgumentException;
import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
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;
/**
* Test cases for the {@link Array2DRowRealMatrix} class.
@@ -163,8 +163,8 @@
public void testFrobeniusNorm() {
Array2DRowRealMatrix m = new Array2DRowRealMatrix(testData);
Array2DRowRealMatrix m2 = new Array2DRowRealMatrix(testData2);
- Assert.assertEquals("testData Frobenius norm", AccurateMath.sqrt(117.0), m.getFrobeniusNorm(), entryTolerance);
- Assert.assertEquals("testData2 Frobenius norm", AccurateMath.sqrt(52.0), m2.getFrobeniusNorm(), entryTolerance);
+ Assert.assertEquals("testData Frobenius norm", JdkMath.sqrt(117.0), m.getFrobeniusNorm(), entryTolerance);
+ Assert.assertEquals("testData2 Frobenius norm", JdkMath.sqrt(52.0), m2.getFrobeniusNorm(), entryTolerance);
}
/** test m-n = m + -n */
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/BiDiagonalTransformerTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/BiDiagonalTransformerTest.java
index 5065898..98dd49c 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/BiDiagonalTransformerTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/BiDiagonalTransformerTest.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.junit.Assert;
import org.junit.Test;
@@ -124,9 +124,9 @@
{ 2.0, 3.0, 4.0 },
{ 3.0, 5.0, 7.0 }
}));
- final double s3 = AccurateMath.sqrt(3.0);
- final double s14 = AccurateMath.sqrt(14.0);
- final double s1553 = AccurateMath.sqrt(1553.0);
+ final double s3 = JdkMath.sqrt(3.0);
+ final double s14 = JdkMath.sqrt(14.0);
+ final double s1553 = JdkMath.sqrt(1553.0);
RealMatrix uRef = MatrixUtils.createRealMatrix(new double[][] {
{ -1.0 / s14, 5.0 / (s3 * s14), 1.0 / s3 },
{ -2.0 / s14, -4.0 / (s3 * s14), 1.0 / s3 },
@@ -162,7 +162,7 @@
public void testMatricesValues() {
BiDiagonalTransformer transformer =
new BiDiagonalTransformer(MatrixUtils.createRealMatrix(testSquare));
- final double s17 = AccurateMath.sqrt(17.0);
+ final double s17 = JdkMath.sqrt(17.0);
RealMatrix uRef = MatrixUtils.createRealMatrix(new double[][] {
{ -8 / (5 * s17), 19 / (5 * s17) },
{ -19 / (5 * s17), -8 / (5 * s17) }
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/BigRealTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/BigRealTest.java
index 97d497a..4e8c348 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/BigRealTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/BigRealTest.java
@@ -22,7 +22,7 @@
import org.apache.commons.math4.legacy.TestUtils;
import org.apache.commons.math4.legacy.exception.MathArithmeticException;
-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;
@@ -125,13 +125,13 @@
@Test
public void testReciprocal() {
BigReal a = new BigReal("1.2345678");
- double eps = AccurateMath.pow(10., -a.getScale());
+ double eps = JdkMath.pow(10., -a.getScale());
BigReal one = new BigReal("1.0000000");
BigReal b = a.reciprocal();
BigReal r = one.subtract(a.multiply(b));
- Assert.assertTrue(AccurateMath.abs(r.doubleValue()) <= eps);
+ Assert.assertTrue(JdkMath.abs(r.doubleValue()) <= eps);
r = one.subtract(b.multiply(a));
- Assert.assertTrue(AccurateMath.abs(r.doubleValue()) <= eps);
+ Assert.assertTrue(JdkMath.abs(r.doubleValue()) <= eps);
}
@Test(expected = MathArithmeticException.class)
@@ -185,7 +185,7 @@
public void testSerial() {
BigReal[] Reals = {
new BigReal(3.0), BigReal.ONE, BigReal.ZERO, new BigReal(17),
- new BigReal(AccurateMath.PI), new BigReal(-2.5)
+ new BigReal(JdkMath.PI), new BigReal(-2.5)
};
for (BigReal Real : Reals) {
Assert.assertEquals(Real, TestUtils.serializeAndRecover(Real));
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/BlockRealMatrixTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/BlockRealMatrixTest.java
index f6ce893..cab4a57 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/BlockRealMatrixTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/BlockRealMatrixTest.java
@@ -27,7 +27,7 @@
import org.apache.commons.math4.legacy.exception.NullArgumentException;
import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
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;
/**
* Test cases for the {@link BlockRealMatrix} class.
@@ -164,8 +164,8 @@
public void testFrobeniusNorm() {
BlockRealMatrix m = new BlockRealMatrix(testData);
BlockRealMatrix m2 = new BlockRealMatrix(testData2);
- Assert.assertEquals("testData Frobenius norm", AccurateMath.sqrt(117.0), m.getFrobeniusNorm(), entryTolerance);
- Assert.assertEquals("testData2 Frobenius norm", AccurateMath.sqrt(52.0), m2.getFrobeniusNorm(), entryTolerance);
+ Assert.assertEquals("testData Frobenius norm", JdkMath.sqrt(117.0), m.getFrobeniusNorm(), entryTolerance);
+ Assert.assertEquals("testData2 Frobenius norm", JdkMath.sqrt(52.0), m2.getFrobeniusNorm(), entryTolerance);
}
/** test m-n = m + -n */
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/ConjugateGradientTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/ConjugateGradientTest.java
index 7365b65..89f7b93 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/ConjugateGradientTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/ConjugateGradientTest.java
@@ -21,7 +21,7 @@
import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
import org.apache.commons.math4.legacy.exception.MathUnsupportedOperationException;
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.junit.Assert;
import org.junit.Test;
@@ -89,7 +89,7 @@
for (int i = 0; i < n; i++) {
final double actual = x.getEntry(i);
final double expected = ainv.getEntry(i, j);
- final double delta = 1E-10 * AccurateMath.abs(expected);
+ final double delta = 1E-10 * JdkMath.abs(expected);
final String msg = String.format("entry[%d][%d]", i, j);
Assert.assertEquals(msg, expected, actual, delta);
}
@@ -115,7 +115,7 @@
for (int i = 0; i < n; i++) {
final double actual = x.getEntry(i);
final double expected = ainv.getEntry(i, j);
- final double delta = 1E-10 * AccurateMath.abs(expected);
+ final double delta = 1E-10 * JdkMath.abs(expected);
final String msg = String.format("entry[%d][%d)", i, j);
Assert.assertEquals(msg, expected, actual, delta);
}
@@ -141,7 +141,7 @@
for (int i = 0; i < n; i++) {
final double actual = x.getEntry(i);
final double expected = ainv.getEntry(i, j);
- final double delta = 1E-10 * AccurateMath.abs(expected);
+ final double delta = 1E-10 * JdkMath.abs(expected);
final String msg = String.format("entry[%d][%d]", i, j);
Assert.assertEquals(msg, expected, actual, delta);
Assert.assertEquals(msg, x0.getEntry(i), 1., Math.ulp(1.));
@@ -206,7 +206,7 @@
for (int i = 0; i < n; i++) {
final double actual = b.getEntry(i) - y.getEntry(i);
final double expected = r.getEntry(i);
- final double delta = 1E-6 * AccurateMath.abs(expected);
+ final double delta = 1E-6 * JdkMath.abs(expected);
final String msg = String
.format("column %d, residual %d", i, j);
Assert.assertEquals(msg, expected, actual, delta);
@@ -322,7 +322,7 @@
for (int i = 0; i < n; i++) {
final double actual = x.getEntry(i);
final double expected = ainv.getEntry(i, j);
- final double delta = 1E-6 * AccurateMath.abs(expected);
+ final double delta = 1E-6 * JdkMath.abs(expected);
final String msg = String.format("coefficient (%d, %d)", i, j);
Assert.assertEquals(msg, expected, actual, delta);
}
@@ -382,7 +382,7 @@
for (int i = 0; i < n; i++) {
final double actual = b.getEntry(i) - y.getEntry(i);
final double expected = r.getEntry(i);
- final double delta = 1E-6 * AccurateMath.abs(expected);
+ final double delta = 1E-6 * JdkMath.abs(expected);
final String msg = String.format("column %d, residual %d", i, j);
Assert.assertEquals(msg, expected, actual, delta);
}
@@ -430,7 +430,7 @@
msg = String.format("row %d, column %d", i, j);
final double expected = x.getEntry(i);
final double actual = px.getEntry(i);
- final double delta = 1E-6 * AccurateMath.abs(expected);
+ final double delta = 1E-6 * JdkMath.abs(expected);
Assert.assertEquals(msg, expected, actual, delta);
}
}
@@ -533,7 +533,7 @@
final double rnorm = r.getNorm();
Assert.assertEquals("iteration performed (residual)",
rnorm, evt.getNormOfResidual(),
- AccurateMath.max(1E-5 * rnorm, 1E-10));
+ JdkMath.max(1E-5 * rnorm, 1E-10));
}
@Override
@@ -584,7 +584,7 @@
final double rnorm = r.getNorm();
Assert.assertEquals("iteration performed (residual)",
rnorm, evt.getNormOfResidual(),
- AccurateMath.max(1E-5 * rnorm, 1E-10));
+ JdkMath.max(1E-5 * rnorm, 1E-10));
}
@Override
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/EigenDecompositionTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/EigenDecompositionTest.java
index 092e48e..8ad86d5 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/EigenDecompositionTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/EigenDecompositionTest.java
@@ -23,7 +23,7 @@
import org.apache.commons.statistics.distribution.ContinuousDistribution;
import org.apache.commons.statistics.distribution.NormalDistribution;
import org.apache.commons.math4.legacy.exception.MathUnsupportedOperationException;
-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;
import org.apache.commons.rng.simple.RandomSource;
@@ -513,7 +513,7 @@
double diffNorm = x.subtract(y).getNorm();
Assert.assertTrue("The norm of (X-Y) is too large: " + diffNorm + ", matrix=" + m.toString(),
- x.subtract(y).getNorm() < 1000 * Precision.EPSILON * AccurateMath.max(x.getNorm(), y.getNorm()));
+ x.subtract(y).getNorm() < 1000 * Precision.EPSILON * JdkMath.max(x.getNorm(), y.getNorm()));
RealMatrix invV = new LUDecomposition(v).getSolver().getInverse();
double norm = v.multiply(d).multiply(invV).subtract(m).getNorm();
@@ -617,11 +617,11 @@
EigenDecomposition ed;
ed = new EigenDecomposition(indefinite);
checkEigenValues(new double[] {2, 1, -1}, ed, 1E-12);
- double isqrt3 = 1/AccurateMath.sqrt(3.0);
+ double isqrt3 = 1/JdkMath.sqrt(3.0);
checkEigenVector(new double[] {isqrt3,isqrt3,-isqrt3}, ed, 1E-12);
- double isqrt2 = 1/AccurateMath.sqrt(2.0);
+ double isqrt2 = 1/JdkMath.sqrt(2.0);
checkEigenVector(new double[] {0.0,-isqrt2,-isqrt2}, ed, 1E-12);
- double isqrt6 = 1/AccurateMath.sqrt(6.0);
+ double isqrt6 = 1/JdkMath.sqrt(6.0);
checkEigenVector(new double[] {2*isqrt6,-isqrt6,isqrt6}, ed, 1E-12);
}
@@ -670,7 +670,7 @@
boolean found = false;
int i = 0;
while (!found && i < searchArray.length) {
- if (AccurateMath.abs(value - searchArray[i]) < tolerance) {
+ if (JdkMath.abs(value - searchArray[i]) < tolerance) {
found = true;
}
i++;
@@ -703,11 +703,11 @@
while (matching && j < searchMatrix.getRowDimension()) {
double colEntry = searchMatrix.getEntry(j, i);
// Use the first entry where both are non-zero as scalar
- if (AccurateMath.abs(multiplier - 1.0) <= AccurateMath.ulp(1.0) && AccurateMath.abs(colEntry) > 1E-14
- && AccurateMath.abs(column[j]) > 1e-14) {
+ if (JdkMath.abs(multiplier - 1.0) <= JdkMath.ulp(1.0) && JdkMath.abs(colEntry) > 1E-14
+ && JdkMath.abs(column[j]) > 1e-14) {
multiplier = colEntry / column[j];
}
- if (AccurateMath.abs(column[j] * multiplier - colEntry) > tolerance) {
+ if (JdkMath.abs(column[j] * multiplier - colEntry) > tolerance) {
matching = false;
}
j++;
@@ -770,7 +770,7 @@
for (final double dataIJ : dataI) {
norm2 += dataIJ * dataIJ;
}
- final double inv = 1.0 / AccurateMath.sqrt(norm2);
+ final double inv = 1.0 / JdkMath.sqrt(norm2);
for (int j = 0; j < size; ++j) {
dataI[j] *= inv;
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/RealVectorAbstractTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/RealVectorAbstractTest.java
index 617b675..456f667 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/RealVectorAbstractTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/RealVectorAbstractTest.java
@@ -53,7 +53,7 @@
import org.apache.commons.math4.legacy.exception.NotPositiveException;
import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
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.junit.Assert;
import org.junit.Test;
@@ -612,7 +612,7 @@
final double delta = data2[i] - data1[i];
expected += delta * delta;
}
- expected = AccurateMath.sqrt(expected);
+ expected = JdkMath.sqrt(expected);
Assert.assertEquals("", expected, actual, 0d);
}
@@ -641,7 +641,7 @@
for (int i = 0; i < data.length; i++) {
expected += data[i] * data[i];
}
- expected = AccurateMath.sqrt(expected);
+ expected = JdkMath.sqrt(expected);
Assert.assertEquals("", expected, actual, 0d);
}
@@ -660,7 +660,7 @@
double expected = 0d;
for (int i = 0; i < data1.length; i++) {
final double delta = data2[i] - data1[i];
- expected += AccurateMath.abs(delta);
+ expected += JdkMath.abs(delta);
}
Assert.assertEquals("", expected, actual, 0d);
}
@@ -688,7 +688,7 @@
final double actual = v.getL1Norm();
double expected = 0d;
for (int i = 0; i < data.length; i++) {
- expected += AccurateMath.abs(data[i]);
+ expected += JdkMath.abs(data[i]);
}
Assert.assertEquals("", expected, actual, 0d);
@@ -709,7 +709,7 @@
double expected = 0d;
for (int i = 0; i < data1.length; i++) {
final double delta = data2[i] - data1[i];
- expected = AccurateMath.max(expected, AccurateMath.abs(delta));
+ expected = JdkMath.max(expected, JdkMath.abs(delta));
}
Assert.assertEquals("", expected, actual, 0d);
}
@@ -737,7 +737,7 @@
final double actual = v.getLInfNorm();
double expected = 0d;
for (int i = 0; i < data.length; i++) {
- expected = AccurateMath.max(expected, AccurateMath.abs(data[i]));
+ expected = JdkMath.max(expected, JdkMath.abs(data[i]));
}
Assert.assertEquals("", expected, actual, 0d);
@@ -850,10 +850,10 @@
final boolean inPlace) {
final double[] data = new double[values.length + 6];
System.arraycopy(values, 0, data, 0, values.length);
- data[values.length + 0] = 0.5 * AccurateMath.PI;
- data[values.length + 1] = -0.5 * AccurateMath.PI;
- data[values.length + 2] = AccurateMath.E;
- data[values.length + 3] = -AccurateMath.E;
+ data[values.length + 0] = 0.5 * JdkMath.PI;
+ data[values.length + 1] = -0.5 * JdkMath.PI;
+ data[values.length + 2] = JdkMath.E;
+ data[values.length + 3] = -JdkMath.E;
data[values.length + 4] = 1.0;
data[values.length + 5] = -1.0;
final double[] expected = new double[data.length];
@@ -1018,7 +1018,7 @@
for (int i = 0; i < data.length; i++) {
norm += data[i] * data[i];
}
- norm = AccurateMath.sqrt(norm);
+ norm = JdkMath.sqrt(norm);
final double[] expected = new double[data.length];
for (int i = 0; i < expected.length; i++) {
expected[i] = data[i] / norm;
@@ -1287,8 +1287,8 @@
norm2 += data2[i] * data2[i];
dotProduct += data1[i] * data2[i];
}
- norm1 = AccurateMath.sqrt(norm1);
- norm2 = AccurateMath.sqrt(norm2);
+ norm1 = JdkMath.sqrt(norm1);
+ norm2 = JdkMath.sqrt(norm2);
final double expected = dotProduct / (norm1 * norm2);
final RealVector v1 = create(data1);
final RealVector v2;
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/SymmLQTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/SymmLQTest.java
index a80dd74..96f1d5c 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/SymmLQTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/SymmLQTest.java
@@ -19,7 +19,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.junit.Assert;
import org.junit.Test;
@@ -53,7 +53,7 @@
}
};
final double shiftm = shift;
- final double pertm = AccurateMath.abs(pertbn);
+ final double pertm = JdkMath.abs(pertbn);
final RealLinearOperator minv;
if (precon) {
minv = new RealLinearOperator() {
@@ -76,7 +76,7 @@
final double[] y = new double[n];
for (int i = 0; i < n; i++) {
double d = (i + 1) * 1.1 / n;
- d = AccurateMath.abs(d - shiftm);
+ d = JdkMath.abs(d - shiftm);
if (i % 10 == 0) {
d += pertm;
}
@@ -255,7 +255,7 @@
for (int i = 0; i < n; i++) {
final double actual = x.getEntry(i);
final double expected = ainv.getEntry(i, j);
- final double delta = 1E-6 * AccurateMath.abs(expected);
+ final double delta = 1E-6 * JdkMath.abs(expected);
final String msg = String.format("entry[%d][%d]", i, j);
Assert.assertEquals(msg, expected, actual, delta);
}
@@ -281,7 +281,7 @@
for (int i = 0; i < n; i++) {
final double actual = x.getEntry(i);
final double expected = ainv.getEntry(i, j);
- final double delta = 1E-6 * AccurateMath.abs(expected);
+ final double delta = 1E-6 * JdkMath.abs(expected);
final String msg = String.format("entry[%d][%d)", i, j);
Assert.assertEquals(msg, expected, actual, delta);
}
@@ -307,7 +307,7 @@
for (int i = 0; i < n; i++) {
final double actual = x.getEntry(i);
final double expected = ainv.getEntry(i, j);
- final double delta = 1E-6 * AccurateMath.abs(expected);
+ final double delta = 1E-6 * JdkMath.abs(expected);
final String msg = String.format("entry[%d][%d]", i, j);
Assert.assertEquals(msg, expected, actual, delta);
Assert.assertEquals(msg, x0.getEntry(i), 1., Math.ulp(1.));
@@ -419,7 +419,7 @@
for (int i = 0; i < n; i++) {
final double actual = x.getEntry(i);
final double expected = ainv.getEntry(i, j);
- final double delta = 1E-6 * AccurateMath.abs(expected);
+ final double delta = 1E-6 * JdkMath.abs(expected);
final String msg = String.format("coefficient (%d, %d)", i, j);
Assert.assertEquals(msg, expected, actual, delta);
}
@@ -464,7 +464,7 @@
msg = String.format("row %d, column %d", i, j);
final double expected = x.getEntry(i);
final double actual = px.getEntry(i);
- final double delta = 5E-5 * AccurateMath.abs(expected);
+ final double delta = 5E-5 * JdkMath.abs(expected);
Assert.assertEquals(msg, expected, actual, delta);
}
}
@@ -609,7 +609,7 @@
final double rnorm = r.getNorm();
Assert.assertEquals("iteration performed (residual)",
rnorm, evt.getNormOfResidual(),
- AccurateMath.max(1E-5 * rnorm, 1E-10));
+ JdkMath.max(1E-5 * rnorm, 1E-10));
}
@Override
@@ -661,7 +661,7 @@
final double rnorm = p.operate(r).getNorm();
Assert.assertEquals("iteration performed (residual)",
rnorm, evt.getNormOfResidual(),
- AccurateMath.max(1E-5 * rnorm, 1E-10));
+ JdkMath.max(1E-5 * rnorm, 1E-10));
}
@Override
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/TriDiagonalTransformerTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/TriDiagonalTransformerTest.java
index 7a8b76c..a8e35b0 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/TriDiagonalTransformerTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/TriDiagonalTransformerTest.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;
import org.junit.Test;
import org.junit.Assert;
@@ -132,7 +132,7 @@
{ 0.0, -0.2581988897471611, 0.6364346693566009, -0.027289660803112598, -0.7263191580755246 }
},
new double[] { 1, 4.4, 1.433099579242636, -0.89537362758743, 2.062274048344794 },
- new double[] { -AccurateMath.sqrt(15), -3.0832882879592476, 0.6082710842351517, 1.1786086405912128 });
+ new double[] { -JdkMath.sqrt(15), -3.0832882879592476, 0.6082710842351517, 1.1786086405912128 });
}
@Test
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/UnmodifiableRealVectorAbstractTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/UnmodifiableRealVectorAbstractTest.java
index 7bbfaba..eabef20 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/UnmodifiableRealVectorAbstractTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/linear/UnmodifiableRealVectorAbstractTest.java
@@ -27,7 +27,7 @@
import org.apache.commons.math4.legacy.analysis.function.Sin;
import org.apache.commons.math4.legacy.exception.MathUnsupportedOperationException;
import org.apache.commons.math4.legacy.linear.RealVector.Entry;
-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;
@@ -85,12 +85,12 @@
public static boolean equals(final double x, final double y) {
if (x == y) {
return true;
- } else if (AccurateMath.abs(x) <= EPS) {
- return AccurateMath.abs(y) <= EPS;
- } else if (AccurateMath.abs(y) <= EPS) {
- return AccurateMath.abs(x) <= EPS;
+ } else if (JdkMath.abs(x) <= EPS) {
+ return JdkMath.abs(y) <= EPS;
+ } else if (JdkMath.abs(y) <= EPS) {
+ return JdkMath.abs(x) <= EPS;
} else {
- return AccurateMath.abs(x - y) <= EPS * AccurateMath.min(AccurateMath.abs(x), AccurateMath.abs(y));
+ return JdkMath.abs(x - y) <= EPS * JdkMath.min(JdkMath.abs(x), JdkMath.abs(y));
}
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ml/distance/EuclideanDistanceTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ml/distance/EuclideanDistanceTest.java
index 206c469..6778da8 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ml/distance/EuclideanDistanceTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ml/distance/EuclideanDistanceTest.java
@@ -18,7 +18,7 @@
import org.junit.Assert;
import org.junit.Test;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
/**
* Tests for {@link EuclideanDistance} class.
@@ -36,7 +36,7 @@
public void test() {
final double[] a = { 1, -2, 3, 4 };
final double[] b = { -5, -6, 7, 8 };
- final double expected = AccurateMath.sqrt(84);
+ final double expected = JdkMath.sqrt(84);
Assert.assertEquals(expected, distance.compute(a, b), 0d);
Assert.assertEquals(expected, distance.compute(b, a), 0d);
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/ContinuousOutputFieldModelTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/ContinuousOutputFieldModelTest.java
index 9a377e7..efa21b1 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/ContinuousOutputFieldModelTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/ContinuousOutputFieldModelTest.java
@@ -28,7 +28,7 @@
import org.apache.commons.math4.legacy.ode.sampling.DummyFieldStepInterpolator;
import org.apache.commons.math4.legacy.ode.sampling.FieldStepInterpolator;
import org.apache.commons.math4.legacy.ode.nonstiff.Decimal64Field;
-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.junit.Assert;
import org.junit.Test;
@@ -123,7 +123,7 @@
FirstOrderFieldIntegrator<T> integ1 =
new DormandPrince853FieldIntegrator<>(field, 0, 1.0, 1.0e-8, 1.0e-8);
integ1.addStepHandler(cm1);
- T t0 = field.getZero().add(AccurateMath.PI);
+ T t0 = field.getZero().add(JdkMath.PI);
T[] y0 = MathArrays.buildArray(field, 2);
y0[0] = field.getOne().negate();
y0[1] = field.getZero();
@@ -136,12 +136,12 @@
FirstOrderFieldIntegrator<T> integ2 =
new DormandPrince853FieldIntegrator<>(field, 0, 0.1, 1.0e-12, 1.0e-12);
integ2.addStepHandler(cm2);
- t0 = field.getZero().add(2.0 * AccurateMath.PI);
+ t0 = field.getZero().add(2.0 * JdkMath.PI);
y0[0] = field.getOne();
y0[1] = field.getZero();
integ2.integrate(new FieldExpandableODE<>(problem),
new FieldODEState<>(t0, y0),
- field.getZero().add(AccurateMath.PI));
+ field.getZero().add(JdkMath.PI));
// merge the two half circles
ContinuousOutputFieldModel<T> cm = new ContinuousOutputFieldModel<>();
@@ -150,12 +150,12 @@
cm.append(cm1);
// check circle
- Assert.assertEquals(2.0 * AccurateMath.PI, cm.getInitialTime().getReal(), 1.0e-12);
+ Assert.assertEquals(2.0 * JdkMath.PI, cm.getInitialTime().getReal(), 1.0e-12);
Assert.assertEquals(0, cm.getFinalTime().getReal(), 1.0e-12);
- for (double t = 0; t < 2.0 * AccurateMath.PI; t += 0.1) {
+ for (double t = 0; t < 2.0 * JdkMath.PI; t += 0.1) {
FieldODEStateAndDerivative<T> interpolated = cm.getInterpolatedState(field.getZero().add(t));
- Assert.assertEquals(AccurateMath.cos(t), interpolated.getState()[0].getReal(), 1.0e-7);
- Assert.assertEquals(AccurateMath.sin(t), interpolated.getState()[1].getReal(), 1.0e-7);
+ Assert.assertEquals(JdkMath.cos(t), interpolated.getState()[0].getReal(), 1.0e-7);
+ Assert.assertEquals(JdkMath.sin(t), interpolated.getState()[1].getReal(), 1.0e-7);
}
}
@@ -222,7 +222,7 @@
}
public void checkValue(double value, double reference) {
- Assert.assertTrue(AccurateMath.abs(value - reference) < 1.0e-10);
+ Assert.assertTrue(JdkMath.abs(value - reference) < 1.0e-10);
}
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/ContinuousOutputModelTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/ContinuousOutputModelTest.java
index cee0678..1af7b45 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/ContinuousOutputModelTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/ContinuousOutputModelTest.java
@@ -28,7 +28,7 @@
import org.apache.commons.math4.legacy.ode.nonstiff.DormandPrince853Integrator;
import org.apache.commons.math4.legacy.ode.sampling.DummyStepInterpolator;
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;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
@@ -77,11 +77,11 @@
double dx = interpolatedY[0] - theoreticalY[0];
double dy = interpolatedY[1] - theoreticalY[1];
double error = dx * dx + dy * dy;
- maxError = AccurateMath.max(maxError, error);
+ maxError = JdkMath.max(maxError, error);
double dxDot = interpolatedYDot[0] - theoreticalYDot[0];
double dyDot = interpolatedYDot[1] - theoreticalYDot[1];
double errorDot = dxDot * dxDot + dyDot * dyDot;
- maxErrorDot = AccurateMath.max(maxErrorDot, errorDot);
+ maxErrorDot = JdkMath.max(maxErrorDot, errorDot);
}
Assert.assertEquals(0.0, maxError, 1.0e-9);
@@ -111,7 +111,7 @@
FirstOrderIntegrator integ1 =
new DormandPrince853Integrator(0, 1.0, 1.0e-8, 1.0e-8);
integ1.addStepHandler(cm1);
- integ1.integrate(problem, AccurateMath.PI, new double[] { -1.0, 0.0 },
+ integ1.integrate(problem, JdkMath.PI, new double[] { -1.0, 0.0 },
0, new double[2]);
// integrate backward from 2π to π
@@ -119,8 +119,8 @@
FirstOrderIntegrator integ2 =
new DormandPrince853Integrator(0, 0.1, 1.0e-12, 1.0e-12);
integ2.addStepHandler(cm2);
- integ2.integrate(problem, 2.0 * AccurateMath.PI, new double[] { 1.0, 0.0 },
- AccurateMath.PI, new double[2]);
+ integ2.integrate(problem, 2.0 * JdkMath.PI, new double[] { 1.0, 0.0 },
+ JdkMath.PI, new double[2]);
// merge the two half circles
ContinuousOutputModel cm = new ContinuousOutputModel();
@@ -129,14 +129,14 @@
cm.append(cm1);
// check circle
- Assert.assertEquals(2.0 * AccurateMath.PI, cm.getInitialTime(), 1.0e-12);
+ Assert.assertEquals(2.0 * JdkMath.PI, cm.getInitialTime(), 1.0e-12);
Assert.assertEquals(0, cm.getFinalTime(), 1.0e-12);
Assert.assertEquals(cm.getFinalTime(), cm.getInterpolatedTime(), 1.0e-12);
- for (double t = 0; t < 2.0 * AccurateMath.PI; t += 0.1) {
+ for (double t = 0; t < 2.0 * JdkMath.PI; t += 0.1) {
cm.setInterpolatedTime(t);
double[] y = cm.getInterpolatedState();
- Assert.assertEquals(AccurateMath.cos(t), y[0], 1.0e-7);
- Assert.assertEquals(AccurateMath.sin(t), y[1], 1.0e-7);
+ Assert.assertEquals(JdkMath.cos(t), y[0], 1.0e-7);
+ Assert.assertEquals(JdkMath.sin(t), y[1], 1.0e-7);
}
}
@@ -183,7 +183,7 @@
}
public void checkValue(double value, double reference) {
- Assert.assertTrue(AccurateMath.abs(value - reference) < 1.0e-10);
+ Assert.assertTrue(JdkMath.abs(value - reference) < 1.0e-10);
}
@Before
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/FirstOrderConverterTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/FirstOrderConverterTest.java
index f585073..5773347 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/FirstOrderConverterTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/FirstOrderConverterTest.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.nonstiff.ClassicalRungeKuttaIntegrator;
-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;
@@ -45,11 +45,11 @@
double previousError = Double.NaN;
for (int i = 0; i < 10; ++i) {
- double step = AccurateMath.pow(2.0, -(i + 1));
+ double step = JdkMath.pow(2.0, -(i + 1));
double error = integrateWithSpecifiedStep(4.0, 0.0, 1.0, step)
- - AccurateMath.sin(4.0);
+ - JdkMath.sin(4.0);
if (i > 0) {
- Assert.assertTrue(AccurateMath.abs(error) < AccurateMath.abs(previousError));
+ Assert.assertTrue(JdkMath.abs(error) < JdkMath.abs(previousError));
}
previousError = error;
@@ -60,16 +60,16 @@
public void testSmallStep()
throws DimensionMismatchException, NumberIsTooSmallException, MaxCountExceededException, NoBracketingException {
double error = integrateWithSpecifiedStep(4.0, 0.0, 1.0, 1.0e-4)
- - AccurateMath.sin(4.0);
- Assert.assertTrue(AccurateMath.abs(error) < 1.0e-10);
+ - JdkMath.sin(4.0);
+ Assert.assertTrue(JdkMath.abs(error) < 1.0e-10);
}
@Test
public void testBigStep()
throws DimensionMismatchException, NumberIsTooSmallException, MaxCountExceededException, NoBracketingException {
double error = integrateWithSpecifiedStep(4.0, 0.0, 1.0, 0.5)
- - AccurateMath.sin(4.0);
- Assert.assertTrue(AccurateMath.abs(error) > 0.1);
+ - JdkMath.sin(4.0);
+ Assert.assertTrue(JdkMath.abs(error) > 0.1);
}
private static class Equations
@@ -103,8 +103,8 @@
double t0, double t,
double step) throws DimensionMismatchException, NumberIsTooSmallException, MaxCountExceededException, NoBracketingException {
double[] y0 = new double[2];
- y0[0] = AccurateMath.sin(omega * t0);
- y0[1] = omega * AccurateMath.cos(omega * t0);
+ y0[0] = JdkMath.sin(omega * t0);
+ y0[1] = omega * JdkMath.cos(omega * t0);
ClassicalRungeKuttaIntegrator i = new ClassicalRungeKuttaIntegrator(step);
double[] y = new double[2];
i.integrate(new FirstOrderConverter(new Equations(1, omega)), t0, y0, t, y);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/JacobianMatricesTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/JacobianMatricesTest.java
index 4ec0f1c..f02ec0a 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/JacobianMatricesTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/JacobianMatricesTest.java
@@ -24,7 +24,7 @@
import org.apache.commons.math4.legacy.ode.JacobianMatrices.MismatchedEquations;
import org.apache.commons.math4.legacy.ode.nonstiff.DormandPrince54Integrator;
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;
import org.junit.Assert;
import org.junit.Test;
@@ -215,7 +215,7 @@
integ.setMaxEvaluations(5000);
- double t = 18 * AccurateMath.PI;
+ double t = 18 * JdkMath.PI;
integ.integrate(efode, t);
y = efode.getPrimaryState();
for (int i = 0; i < y.length; ++i) {
@@ -279,7 +279,7 @@
integ.setMaxEvaluations(50000);
- double t = 18 * AccurateMath.PI;
+ double t = 18 * JdkMath.PI;
integ.integrate(efode, t);
y = efode.getPrimaryState();
for (int i = 0; i < y.length; ++i) {
@@ -473,8 +473,8 @@
}
public double[] exactY(double t) {
- double cos = AccurateMath.cos(omega * t);
- double sin = AccurateMath.sin(omega * t);
+ double cos = JdkMath.cos(omega * t);
+ double sin = JdkMath.sin(omega * t);
double dx0 = y0[0] - cx;
double dy0 = y0[1] - cy;
return new double[] {
@@ -484,8 +484,8 @@
}
public double[][] exactDyDy0(double t) {
- double cos = AccurateMath.cos(omega * t);
- double sin = AccurateMath.sin(omega * t);
+ double cos = JdkMath.cos(omega * t);
+ double sin = JdkMath.sin(omega * t);
return new double[][] {
{ cos, -sin },
{ sin, cos }
@@ -493,20 +493,20 @@
}
public double[] exactDyDcx(double t) {
- double cos = AccurateMath.cos(omega * t);
- double sin = AccurateMath.sin(omega * t);
+ double cos = JdkMath.cos(omega * t);
+ double sin = JdkMath.sin(omega * t);
return new double[] {1 - cos, -sin};
}
public double[] exactDyDcy(double t) {
- double cos = AccurateMath.cos(omega * t);
- double sin = AccurateMath.sin(omega * t);
+ double cos = JdkMath.cos(omega * t);
+ double sin = JdkMath.sin(omega * t);
return new double[] {sin, 1 - cos};
}
public double[] exactDyDom(double t) {
- double cos = AccurateMath.cos(omega * t);
- double sin = AccurateMath.sin(omega * t);
+ double cos = JdkMath.cos(omega * t);
+ double sin = JdkMath.sin(omega * t);
double dx0 = y0[0] - cx;
double dy0 = y0[1] - cy;
return new double[] { -t * (sin * dx0 + cos * dy0) , t * (cos * dx0 - sin * dy0) };
@@ -575,8 +575,8 @@
}
public double[] exactY(double t) {
- double cos = AccurateMath.cos(omega * t);
- double sin = AccurateMath.sin(omega * t);
+ double cos = JdkMath.cos(omega * t);
+ double sin = JdkMath.sin(omega * t);
double dx0 = y0[0] - cx;
double dy0 = y0[1] - cy;
return new double[] {
@@ -586,8 +586,8 @@
}
public double[][] exactDyDy0(double t) {
- double cos = AccurateMath.cos(omega * t);
- double sin = AccurateMath.sin(omega * t);
+ double cos = JdkMath.cos(omega * t);
+ double sin = JdkMath.sin(omega * t);
return new double[][] {
{ cos, -sin },
{ sin, cos }
@@ -595,20 +595,20 @@
}
public double[] exactDyDcx(double t) {
- double cos = AccurateMath.cos(omega * t);
- double sin = AccurateMath.sin(omega * t);
+ double cos = JdkMath.cos(omega * t);
+ double sin = JdkMath.sin(omega * t);
return new double[] {1 - cos, -sin};
}
public double[] exactDyDcy(double t) {
- double cos = AccurateMath.cos(omega * t);
- double sin = AccurateMath.sin(omega * t);
+ double cos = JdkMath.cos(omega * t);
+ double sin = JdkMath.sin(omega * t);
return new double[] {sin, 1 - cos};
}
public double[] exactDyDom(double t) {
- double cos = AccurateMath.cos(omega * t);
- double sin = AccurateMath.sin(omega * t);
+ double cos = JdkMath.cos(omega * t);
+ double sin = JdkMath.sin(omega * t);
double dx0 = y0[0] - cx;
double dy0 = y0[1] - cy;
return new double[] { -t * (sin * dx0 + cos * dy0) , t * (cos * dx0 - sin * dy0) };
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestFieldProblem4.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestFieldProblem4.java
index 3deb8db..ba59081 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestFieldProblem4.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestFieldProblem4.java
@@ -23,7 +23,7 @@
import org.apache.commons.math4.legacy.core.RealFieldElement;
import org.apache.commons.math4.legacy.ode.events.Action;
import org.apache.commons.math4.legacy.ode.events.FieldEventHandler;
-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;
/**
@@ -79,10 +79,10 @@
@Override
public T[] getTheoreticalEventsTimes() {
T[] array = MathArrays.buildArray(getField(), 5);
- array[0] = a.negate().add(1 * AccurateMath.PI);
- array[1] = a.negate().add(2 * AccurateMath.PI);
- array[2] = a.negate().add(3 * AccurateMath.PI);
- array[3] = a.negate().add(4 * AccurateMath.PI);
+ array[0] = a.negate().add(1 * JdkMath.PI);
+ array[1] = a.negate().add(2 * JdkMath.PI);
+ array[2] = a.negate().add(3 * JdkMath.PI);
+ array[3] = a.negate().add(4 * JdkMath.PI);
array[4] = convert(120.0);
return array;
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblem1.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblem1.java
index 3735d61..033ce46 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblem1.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblem1.java
@@ -17,7 +17,7 @@
package org.apache.commons.math4.legacy.ode;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
/**
* This class is used in the junit tests for the ODE integrators.
@@ -64,7 +64,7 @@
@Override
public double[] computeTheoreticalState(double t) {
- double c = AccurateMath.exp (getInitialTime() - t);
+ double c = JdkMath.exp (getInitialTime() - t);
for (int i = 0; i < getDimension(); ++i) {
y[i] = c * getInitialState()[i];
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblem2.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblem2.java
index ad82ae7..74706b0 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblem2.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblem2.java
@@ -17,7 +17,7 @@
package org.apache.commons.math4.legacy.ode;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
/**
* This class is used in the junit tests for the ODE integrators.
@@ -66,7 +66,7 @@
@Override
public double[] computeTheoreticalState(double t) {
double t2 = t * t;
- double c = t2 + 2 * (AccurateMath.exp (-0.5 * t2) - 1);
+ double c = t2 + 2 * (JdkMath.exp (-0.5 * t2) - 1);
for (int i = 0; i < getDimension(); ++i) {
y[i] = c;
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblem3.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblem3.java
index 721037b..1a3d00f 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblem3.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblem3.java
@@ -17,7 +17,7 @@
package org.apache.commons.math4.legacy.ode;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
/**
* This class is used in the junit tests for the ODE integrators.
@@ -52,7 +52,7 @@
public TestProblem3(double e) {
super();
this.e = e;
- double[] y0 = { 1 - e, 0, 0, AccurateMath.sqrt((1+e)/(1-e)) };
+ double[] y0 = { 1 - e, 0, 0, JdkMath.sqrt((1+e)/(1-e)) };
setInitialConditions(0.0, y0);
setFinalConditions(20.0);
double[] errorScale = { 1.0, 1.0, 1.0, 1.0 };
@@ -72,7 +72,7 @@
// current radius
double r2 = y[0] * y[0] + y[1] * y[1];
- double invR3 = 1 / (r2 * AccurateMath.sqrt(r2));
+ double invR3 = 1 / (r2 * JdkMath.sqrt(r2));
// compute the derivatives
yDot[0] = y[2];
@@ -89,23 +89,23 @@
double E = t;
double d = 0;
double corr = 999.0;
- for (int i = 0; (i < 50) && (AccurateMath.abs(corr) > 1.0e-12); ++i) {
- double f2 = e * AccurateMath.sin(E);
+ for (int i = 0; (i < 50) && (JdkMath.abs(corr) > 1.0e-12); ++i) {
+ double f2 = e * JdkMath.sin(E);
double f0 = d - f2;
- double f1 = 1 - e * AccurateMath.cos(E);
+ double f1 = 1 - e * JdkMath.cos(E);
double f12 = f1 + f1;
corr = f0 * f12 / (f1 * f12 - f0 * f2);
d -= corr;
E = t + d;
}
- double cosE = AccurateMath.cos(E);
- double sinE = AccurateMath.sin(E);
+ double cosE = JdkMath.cos(E);
+ double sinE = JdkMath.sin(E);
y[0] = cosE - e;
- y[1] = AccurateMath.sqrt(1 - e * e) * sinE;
+ y[1] = JdkMath.sqrt(1 - e * e) * sinE;
y[2] = -sinE / (1 - e * cosE);
- y[3] = AccurateMath.sqrt(1 - e * e) * cosE / (1 - e * cosE);
+ y[3] = JdkMath.sqrt(1 - e * e) * cosE / (1 - e * cosE);
return y;
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblem4.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblem4.java
index 2ba0f89..9b6172a 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblem4.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblem4.java
@@ -18,7 +18,7 @@
package org.apache.commons.math4.legacy.ode;
import org.apache.commons.math4.legacy.ode.events.EventHandler;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
/**
* This class is used in the junit tests for the ODE integrators.
@@ -48,7 +48,7 @@
public TestProblem4() {
super();
a = 1.2;
- double[] y0 = { AccurateMath.sin(a), AccurateMath.cos(a) };
+ double[] y0 = { JdkMath.sin(a), JdkMath.cos(a) };
setInitialConditions(0.0, y0);
setFinalConditions(15);
double[] errorScale = { 1.0, 0.0 };
@@ -68,10 +68,10 @@
@Override
public double[] getTheoreticalEventsTimes() {
return new double[] {
- 1 * AccurateMath.PI - a,
- 2 * AccurateMath.PI - a,
- 3 * AccurateMath.PI - a,
- 4 * AccurateMath.PI - a,
+ 1 * JdkMath.PI - a,
+ 2 * JdkMath.PI - a,
+ 3 * JdkMath.PI - a,
+ 4 * JdkMath.PI - a,
12.0
};
}
@@ -84,9 +84,9 @@
@Override
public double[] computeTheoreticalState(double t) {
- double sin = AccurateMath.sin(t + a);
- double cos = AccurateMath.cos(t + a);
- y[0] = AccurateMath.abs(sin);
+ double sin = JdkMath.sin(t + a);
+ double cos = JdkMath.cos(t + a);
+ y[0] = JdkMath.abs(sin);
y[1] = (sin >= 0) ? cos : -cos;
return y;
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblemHandler.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblemHandler.java
index 9d1b6e0..0d7a443 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblemHandler.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/TestProblemHandler.java
@@ -20,7 +20,7 @@
import org.apache.commons.math4.legacy.exception.MaxCountExceededException;
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 used to handle steps for the test problems
@@ -74,17 +74,17 @@
public void handleStep(StepInterpolator interpolator, boolean isLast) throws MaxCountExceededException {
double start = integrator.getCurrentStepStart();
- if (AccurateMath.abs((start - problem.getInitialTime()) / integrator.getCurrentSignedStepsize()) > 0.001) {
+ if (JdkMath.abs((start - problem.getInitialTime()) / integrator.getCurrentSignedStepsize()) > 0.001) {
// multistep integrators do not handle the first steps themselves
// so we have to make sure the integrator we look at has really started its work
if (!Double.isNaN(expectedStepStart)) {
// the step should either start at the end of the integrator step
// or at an event if the step is split into several substeps
- double stepError = AccurateMath.max(maxTimeError, AccurateMath.abs(start - expectedStepStart));
+ double stepError = JdkMath.max(maxTimeError, JdkMath.abs(start - expectedStepStart));
for (double eventTime : problem.getTheoreticalEventsTimes()) {
- stepError = AccurateMath.min(stepError, AccurateMath.abs(start - eventTime));
+ stepError = JdkMath.min(stepError, JdkMath.abs(start - eventTime));
}
- maxTimeError = AccurateMath.max(maxTimeError, stepError);
+ maxTimeError = JdkMath.max(maxTimeError, stepError);
}
expectedStepStart = start + integrator.getCurrentSignedStepsize();
}
@@ -99,8 +99,8 @@
double[] interpolatedY = interpolator.getInterpolatedState();
double[] theoreticalY = problem.computeTheoreticalState(cT);
for (int i = 0; i < interpolatedY.length; ++i) {
- double error = AccurateMath.abs(interpolatedY[i] - theoreticalY[i]);
- lastError = AccurateMath.max(error, lastError);
+ double error = JdkMath.abs(interpolatedY[i] - theoreticalY[i]);
+ lastError = JdkMath.max(error, lastError);
}
lastTime = cT;
}
@@ -114,8 +114,8 @@
// update the errors
for (int i = 0; i < interpolatedY.length; ++i) {
- double error = errorScale[i] * AccurateMath.abs(interpolatedY[i] - theoreticalY[i]);
- maxValueError = AccurateMath.max(error, maxValueError);
+ double error = errorScale[i] * JdkMath.abs(interpolatedY[i] - theoreticalY[i]);
+ maxValueError = JdkMath.max(error, maxValueError);
}
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/events/EventFilterTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/events/EventFilterTest.java
index 9df7bcc..abc02e2 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/events/EventFilterTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/events/EventFilterTest.java
@@ -26,7 +26,7 @@
import org.apache.commons.math4.legacy.ode.nonstiff.DormandPrince853Integrator;
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;
@@ -37,15 +37,15 @@
// start point: g > 0
testHistory(FilterType.TRIGGER_ONLY_INCREASING_EVENTS,
- 0.5 * AccurateMath.PI, 30.5 * AccurateMath.PI, AccurateMath.PI, -1);
+ 0.5 * JdkMath.PI, 30.5 * JdkMath.PI, JdkMath.PI, -1);
// start point: g = 0
testHistory(FilterType.TRIGGER_ONLY_INCREASING_EVENTS,
- 0, 30.5 * AccurateMath.PI, AccurateMath.PI, -1);
+ 0, 30.5 * JdkMath.PI, JdkMath.PI, -1);
// start point: g < 0
testHistory(FilterType.TRIGGER_ONLY_INCREASING_EVENTS,
- 1.5 * AccurateMath.PI, 30.5 * AccurateMath.PI, AccurateMath.PI, +1);
+ 1.5 * JdkMath.PI, 30.5 * JdkMath.PI, JdkMath.PI, +1);
}
@@ -54,15 +54,15 @@
// start point: g > 0
testHistory(FilterType.TRIGGER_ONLY_INCREASING_EVENTS,
- 0.5 * AccurateMath.PI, -30.5 * AccurateMath.PI, AccurateMath.PI, -1);
+ 0.5 * JdkMath.PI, -30.5 * JdkMath.PI, JdkMath.PI, -1);
// start point: g = 0
testHistory(FilterType.TRIGGER_ONLY_INCREASING_EVENTS,
- 0, -30.5 * AccurateMath.PI, AccurateMath.PI, +1);
+ 0, -30.5 * JdkMath.PI, JdkMath.PI, +1);
// start point: g < 0
testHistory(FilterType.TRIGGER_ONLY_INCREASING_EVENTS,
- 1.5 * AccurateMath.PI, -30.5 * AccurateMath.PI, AccurateMath.PI, -1);
+ 1.5 * JdkMath.PI, -30.5 * JdkMath.PI, JdkMath.PI, -1);
}
@@ -71,15 +71,15 @@
// start point: g > 0
testHistory(FilterType.TRIGGER_ONLY_DECREASING_EVENTS,
- 0.5 * AccurateMath.PI, 30.5 * AccurateMath.PI, 0, +1);
+ 0.5 * JdkMath.PI, 30.5 * JdkMath.PI, 0, +1);
// start point: g = 0
testHistory(FilterType.TRIGGER_ONLY_DECREASING_EVENTS,
- 0, 30.5 * AccurateMath.PI, 0, +1);
+ 0, 30.5 * JdkMath.PI, 0, +1);
// start point: g < 0
testHistory(FilterType.TRIGGER_ONLY_DECREASING_EVENTS,
- 1.5 * AccurateMath.PI, 30.5 * AccurateMath.PI, 0, +1);
+ 1.5 * JdkMath.PI, 30.5 * JdkMath.PI, 0, +1);
}
@@ -88,15 +88,15 @@
// start point: g > 0
testHistory(FilterType.TRIGGER_ONLY_DECREASING_EVENTS,
- 0.5 * AccurateMath.PI, -30.5 * AccurateMath.PI, 0, -1);
+ 0.5 * JdkMath.PI, -30.5 * JdkMath.PI, 0, -1);
// start point: g = 0
testHistory(FilterType.TRIGGER_ONLY_DECREASING_EVENTS,
- 0, -30.5 * AccurateMath.PI, 0, -1);
+ 0, -30.5 * JdkMath.PI, 0, -1);
// start point: g < 0
testHistory(FilterType.TRIGGER_ONLY_DECREASING_EVENTS,
- 1.5 * AccurateMath.PI, -30.5 * AccurateMath.PI, 0, +1);
+ 1.5 * JdkMath.PI, -30.5 * JdkMath.PI, 0, +1);
}
@@ -107,23 +107,23 @@
eventFilter.init(t0, new double[] {1.0, 0.0}, t1);
// first pass to set up switches history for a long period
- double h = AccurateMath.copySign(0.05, t1 - t0);
- double n = (int) AccurateMath.floor((t1 - t0) / h);
+ double h = JdkMath.copySign(0.05, t1 - t0);
+ double n = (int) JdkMath.floor((t1 - t0) / h);
for (int i = 0; i < n; ++i) {
double t = t0 + i * h;
- eventFilter.g(t, new double[] { AccurateMath.sin(t), AccurateMath.cos(t) });
+ eventFilter.g(t, new double[] { JdkMath.sin(t), JdkMath.cos(t) });
}
// verify old events are preserved, even if randomly accessed
UniformRandomProvider rng = RandomSource.TWO_CMRES.create(0xb0e7401265af8cd3L);
for (int i = 0; i < 5000; i++) {
double t = t0 + (t1 - t0) * rng.nextDouble();
- double g = eventFilter.g(t, new double[] { AccurateMath.sin(t), AccurateMath.cos(t) });
- int turn = (int) AccurateMath.floor((t - refSwitch) / (2 * AccurateMath.PI));
+ double g = eventFilter.g(t, new double[] { JdkMath.sin(t), JdkMath.cos(t) });
+ int turn = (int) JdkMath.floor((t - refSwitch) / (2 * JdkMath.PI));
if (turn % 2 == 0) {
- Assert.assertEquals( signEven * AccurateMath.sin(t), g, 1.0e-10);
+ Assert.assertEquals( signEven * JdkMath.sin(t), g, 1.0e-10);
} else {
- Assert.assertEquals(-signEven * AccurateMath.sin(t), g, 1.0e-10);
+ Assert.assertEquals(-signEven * JdkMath.sin(t), g, 1.0e-10);
}
}
@@ -144,8 +144,8 @@
FilterType.TRIGGER_ONLY_INCREASING_EVENTS),
0.1, e, 100,
new BracketingNthOrderBrentSolver(1.0e-7, 5));
- double t0 = 0.5 * AccurateMath.PI;
- double tEnd = 5.5 * AccurateMath.PI;
+ double t0 = 0.5 * JdkMath.PI;
+ double tEnd = 5.5 * JdkMath.PI;
double[] y = { 0.0, 1.0 };
Assert.assertEquals(tEnd,
integrator.integrate(new SineCosine(), t0, y, tEnd, y),
@@ -171,8 +171,8 @@
FilterType.TRIGGER_ONLY_DECREASING_EVENTS),
0.1, e, 1000,
new BracketingNthOrderBrentSolver(1.0e-7, 5));
- double t0 = 0.5 * AccurateMath.PI;
- double tEnd = 5.5 * AccurateMath.PI;
+ double t0 = 0.5 * JdkMath.PI;
+ double tEnd = 5.5 * JdkMath.PI;
double[] y = { 0.0, 1.0 };
Assert.assertEquals(tEnd,
integrator.integrate(new SineCosine(), t0, y, tEnd, y),
@@ -203,8 +203,8 @@
FilterType.TRIGGER_ONLY_DECREASING_EVENTS),
0.1, e, 1000,
new BracketingNthOrderBrentSolver(1.0e-7, 5));
- double t0 = 0.5 * AccurateMath.PI;
- double tEnd = 5.5 * AccurateMath.PI;
+ double t0 = 0.5 * JdkMath.PI;
+ double tEnd = 5.5 * JdkMath.PI;
double[] y = { 0.0, 1.0 };
Assert.assertEquals(tEnd,
integrator.integrate(new SineCosine(), t0, y, tEnd, y),
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AbstractEmbeddedRungeKuttaFieldIntegratorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AbstractEmbeddedRungeKuttaFieldIntegratorTest.java
index 4647431..0720bec 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AbstractEmbeddedRungeKuttaFieldIntegratorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AbstractEmbeddedRungeKuttaFieldIntegratorTest.java
@@ -39,7 +39,7 @@
import org.apache.commons.math4.legacy.ode.events.FieldEventHandler;
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;
import org.junit.Assert;
import org.junit.Test;
@@ -122,7 +122,7 @@
if (regularArray[i] == 0) {
Assert.assertEquals(0.0, fieldArray[i].getReal(), 0.0);
} else {
- Assert.assertEquals(regularArray[i], fieldArray[i].getReal(), AccurateMath.ulp(regularArray[i]));
+ Assert.assertEquals(regularArray[i], fieldArray[i].getReal(), JdkMath.ulp(regularArray[i]));
}
}
}
@@ -212,7 +212,7 @@
TestFieldProblem1<T> pb = new TestFieldProblem1<>(field);
double minStep = 0;
double maxStep = pb.getFinalTime().subtract(pb.getInitialState().getTime()).getReal();
- double scalAbsoluteTolerance = AccurateMath.pow(10.0, i);
+ double scalAbsoluteTolerance = JdkMath.pow(10.0, i);
double scalRelativeTolerance = 0.01 * scalAbsoluteTolerance;
FirstOrderFieldIntegrator<T> integ = createIntegrator(field, minStep, maxStep,
@@ -577,7 +577,7 @@
public double[] theoreticalY(final double t) {
final double theta = omega.getReal() * t + alpha.getReal();
return new double[] {
- r.getReal() * AccurateMath.sin(theta), r.getReal() * AccurateMath.cos(theta)
+ r.getReal() * JdkMath.sin(theta), r.getReal() * JdkMath.cos(theta)
};
}
@@ -585,8 +585,8 @@
// intermediate angle and state
final double theta = omega.getReal() * t + alpha.getReal();
- final double sin = AccurateMath.sin(theta);
- final double cos = AccurateMath.cos(theta);
+ final double sin = JdkMath.sin(theta);
+ final double cos = JdkMath.cos(theta);
final double y0 = r.getReal() * sin;
final double y1 = r.getReal() * cos;
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AbstractRungeKuttaFieldIntegratorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AbstractRungeKuttaFieldIntegratorTest.java
index d0a2702..0fc4066 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AbstractRungeKuttaFieldIntegratorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AbstractRungeKuttaFieldIntegratorTest.java
@@ -44,7 +44,7 @@
import org.apache.commons.math4.legacy.ode.sampling.FieldStepHandler;
import org.apache.commons.math4.legacy.ode.sampling.FieldStepInterpolator;
import org.apache.commons.math4.legacy.ode.sampling.StepInterpolatorTestUtils;
-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.junit.Assert;
import org.junit.Test;
@@ -108,7 +108,7 @@
if (regularArray[i] == 0) {
Assert.assertEquals(0.0, fieldArray[i].getReal(), 0.0);
} else {
- Assert.assertEquals(regularArray[i], fieldArray[i].getReal(), AccurateMath.ulp(regularArray[i]));
+ Assert.assertEquals(regularArray[i], fieldArray[i].getReal(), JdkMath.ulp(regularArray[i]));
}
}
}
@@ -250,7 +250,7 @@
T previousTimeError = null;
for (int i = 4; i < 10; ++i) {
- T step = pb.getFinalTime().subtract(pb.getInitialState().getTime()).multiply(AccurateMath.pow(2.0, -i));
+ T step = pb.getFinalTime().subtract(pb.getInitialState().getTime()).multiply(JdkMath.pow(2.0, -i));
RungeKuttaFieldIntegrator<T> integ = createIntegrator(field, step);
TestFieldProblemHandler<T> handler = new TestFieldProblemHandler<>(pb, integ);
@@ -497,8 +497,8 @@
@Override
public T[] computeDerivatives(T t, T[] y) {
- Assert.assertTrue(t.getReal() >= AccurateMath.nextAfter(t0.getReal(), Double.NEGATIVE_INFINITY));
- Assert.assertTrue(t.getReal() <= AccurateMath.nextAfter(t.getReal(), Double.POSITIVE_INFINITY));
+ Assert.assertTrue(t.getReal() >= JdkMath.nextAfter(t0.getReal(), Double.NEGATIVE_INFINITY));
+ Assert.assertTrue(t.getReal() <= JdkMath.nextAfter(t.getReal(), Double.POSITIVE_INFINITY));
T[] yDot = MathArrays.buildArray(field, 1);
yDot[0] = y[0].multiply(-100.0);
return yDot;
@@ -643,7 +643,7 @@
public double[] theoreticalY(final double t) {
final double theta = omega.getReal() * t + alpha.getReal();
return new double[] {
- r.getReal() * AccurateMath.sin(theta), r.getReal() * AccurateMath.cos(theta)
+ r.getReal() * JdkMath.sin(theta), r.getReal() * JdkMath.cos(theta)
};
}
@@ -651,8 +651,8 @@
// intermediate angle and state
final double theta = omega.getReal() * t + alpha.getReal();
- final double sin = AccurateMath.sin(theta);
- final double cos = AccurateMath.cos(theta);
+ final double sin = JdkMath.sin(theta);
+ final double cos = JdkMath.cos(theta);
final double y0 = r.getReal() * sin;
final double y1 = r.getReal() * cos;
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsBashforthIntegratorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsBashforthIntegratorTest.java
index 155079c..802710a 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsBashforthIntegratorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsBashforthIntegratorTest.java
@@ -37,7 +37,7 @@
import org.apache.commons.math4.legacy.ode.TestProblemHandler;
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;
import org.junit.Assert;
import org.junit.Test;
@@ -81,7 +81,7 @@
TestProblem1 pb = new TestProblem1();
double minStep = 0;
double maxStep = pb.getFinalTime() - pb.getInitialTime();
- double scalAbsoluteTolerance = AccurateMath.pow(10.0, i);
+ double scalAbsoluteTolerance = JdkMath.pow(10.0, i);
double scalRelativeTolerance = 0.01 * scalAbsoluteTolerance;
FirstOrderIntegrator integ = new AdamsBashforthIntegrator(4, minStep, maxStep,
@@ -128,7 +128,7 @@
public void backward() throws DimensionMismatchException, NumberIsTooSmallException, MaxCountExceededException, NoBracketingException {
TestProblem5 pb = new TestProblem5();
- double range = AccurateMath.abs(pb.getFinalTime() - pb.getInitialTime());
+ double range = JdkMath.abs(pb.getFinalTime() - pb.getInitialTime());
AdamsBashforthIntegrator integ = new AdamsBashforthIntegrator(4, 0, range, 1.0e-12, 1.0e-12);
integ.setStarterIntegrator(new PerfectStarter(pb, (integ.getNSteps() + 5) / 2));
@@ -146,7 +146,7 @@
@Test
public void polynomial() throws DimensionMismatchException, NumberIsTooSmallException, MaxCountExceededException, NoBracketingException {
TestProblem6 pb = new TestProblem6();
- double range = AccurateMath.abs(pb.getFinalTime() - pb.getInitialTime());
+ double range = JdkMath.abs(pb.getFinalTime() - pb.getInitialTime());
for (int nSteps = 2; nSteps < 8; ++nSteps) {
AdamsBashforthIntegrator integ =
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsFieldIntegratorAbstractTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsFieldIntegratorAbstractTest.java
index 70ecc0e..464a331 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsFieldIntegratorAbstractTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsFieldIntegratorAbstractTest.java
@@ -36,7 +36,7 @@
import org.apache.commons.math4.legacy.ode.TestFieldProblemHandler;
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.junit.Assert;
import org.junit.Test;
@@ -81,7 +81,7 @@
TestFieldProblem1<T> pb = new TestFieldProblem1<>(field);
double minStep = 0;
double maxStep = pb.getFinalTime().subtract(pb.getInitialState().getTime()).getReal();
- double scalAbsoluteTolerance = AccurateMath.pow(10.0, i);
+ double scalAbsoluteTolerance = JdkMath.pow(10.0, i);
double scalRelativeTolerance = 0.01 * scalAbsoluteTolerance;
FirstOrderFieldIntegrator<T> integ = createIntegrator(field, 4, minStep, maxStep,
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsMoultonIntegratorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsMoultonIntegratorTest.java
index 820b9fa..d4eecc5 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsMoultonIntegratorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/AdamsMoultonIntegratorTest.java
@@ -35,7 +35,7 @@
import org.apache.commons.math4.legacy.ode.TestProblemHandler;
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;
import org.junit.Assert;
import org.junit.Test;
@@ -85,7 +85,7 @@
TestProblem1 pb = new TestProblem1();
double minStep = 0;
double maxStep = pb.getFinalTime() - pb.getInitialTime();
- double scalAbsoluteTolerance = AccurateMath.pow(10.0, i);
+ double scalAbsoluteTolerance = JdkMath.pow(10.0, i);
double scalRelativeTolerance = 0.01 * scalAbsoluteTolerance;
FirstOrderIntegrator integ = new AdamsMoultonIntegrator(4, minStep, maxStep,
@@ -137,7 +137,7 @@
MaxCountExceededException, NoBracketingException {
TestProblem5 pb = new TestProblem5();
- double range = AccurateMath.abs(pb.getFinalTime() - pb.getInitialTime());
+ double range = JdkMath.abs(pb.getFinalTime() - pb.getInitialTime());
FirstOrderIntegrator integ = new AdamsMoultonIntegrator(4, 0, range, 1.0e-12, 1.0e-12);
TestProblemHandler handler = new TestProblemHandler(pb, integ);
@@ -156,7 +156,7 @@
throws DimensionMismatchException, NumberIsTooSmallException,
MaxCountExceededException, NoBracketingException {
TestProblem6 pb = new TestProblem6();
- double range = AccurateMath.abs(pb.getFinalTime() - pb.getInitialTime());
+ double range = JdkMath.abs(pb.getFinalTime() - pb.getInitialTime());
for (int nSteps = 2; nSteps < 8; ++nSteps) {
AdamsMoultonIntegrator integ =
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/ClassicalRungeKuttaIntegratorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/ClassicalRungeKuttaIntegratorTest.java
index 418e106..dac7a22 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/ClassicalRungeKuttaIntegratorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/ClassicalRungeKuttaIntegratorTest.java
@@ -35,7 +35,7 @@
import org.apache.commons.math4.legacy.ode.events.EventHandler;
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;
import org.junit.Assert;
import org.junit.Test;
@@ -74,7 +74,7 @@
double finalT = integrator.integrate(ode, t0, y0, tEvent, y);
Assert.assertEquals(tEvent, finalT, 5.0e-6);
for (int i = 0; i < y.length; ++i) {
- Assert.assertEquals(y0[i] * AccurateMath.exp(k[i] * (finalT - t0)), y[i], 1.0e-9);
+ Assert.assertEquals(y0[i] * JdkMath.exp(k[i] * (finalT - t0)), y[i], 1.0e-9);
}
integrator.addEventHandler(new EventHandler() {
@@ -101,7 +101,7 @@
finalT = integrator.integrate(ode, t0, y0, tEvent + 120, y);
Assert.assertEquals(tEvent + 120, finalT, 5.0e-6);
for (int i = 0; i < y.length; ++i) {
- Assert.assertEquals(y0[i] * AccurateMath.exp(k[i] * (finalT - t0)), y[i], 1.0e-9);
+ Assert.assertEquals(y0[i] * JdkMath.exp(k[i] * (finalT - t0)), y[i], 1.0e-9);
}
}
@@ -150,7 +150,7 @@
double previousTimeError = Double.NaN;
for (int i = 4; i < 10; ++i) {
- double step = (pb.getFinalTime() - pb.getInitialTime()) * AccurateMath.pow(2.0, -i);
+ double step = (pb.getFinalTime() - pb.getInitialTime()) * JdkMath.pow(2.0, -i);
FirstOrderIntegrator integ = new ClassicalRungeKuttaIntegrator(step);
TestProblemHandler handler = new TestProblemHandler(pb, integ);
@@ -169,13 +169,13 @@
double error = handler.getMaximalValueError();
if (i > 4) {
- Assert.assertTrue(error < 1.01 * AccurateMath.abs(previousValueError));
+ Assert.assertTrue(error < 1.01 * JdkMath.abs(previousValueError));
}
previousValueError = error;
double timeError = handler.getMaximalTimeError();
if (i > 4) {
- Assert.assertTrue(timeError <= AccurateMath.abs(previousTimeError));
+ Assert.assertTrue(timeError <= JdkMath.abs(previousTimeError));
}
previousTimeError = timeError;
@@ -233,7 +233,7 @@
MaxCountExceededException, NoBracketingException {
TestProblem5 pb = new TestProblem5();
- double step = AccurateMath.abs(pb.getFinalTime() - pb.getInitialTime()) * 0.001;
+ double step = JdkMath.abs(pb.getFinalTime() - pb.getInitialTime()) * 0.001;
FirstOrderIntegrator integ = new ClassicalRungeKuttaIntegrator(step);
TestProblemHandler handler = new TestProblemHandler(pb, integ);
@@ -340,8 +340,8 @@
@Override
public void computeDerivatives(double t, double[] y, double[] yDot) {
- Assert.assertTrue(t >= AccurateMath.nextAfter(start, Double.NEGATIVE_INFINITY));
- Assert.assertTrue(t <= AccurateMath.nextAfter(end, Double.POSITIVE_INFINITY));
+ Assert.assertTrue(t >= JdkMath.nextAfter(start, Double.NEGATIVE_INFINITY));
+ Assert.assertTrue(t <= JdkMath.nextAfter(end, Double.POSITIVE_INFINITY));
yDot[0] = -100.0 * y[0];
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/Decimal64.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/Decimal64.java
index 626d2d8..5a8aa0d 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/Decimal64.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/Decimal64.java
@@ -17,7 +17,7 @@
package org.apache.commons.math4.legacy.ode.nonstiff;
import org.apache.commons.numbers.core.Sum;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
import org.apache.commons.math4.legacy.core.Field;
import org.apache.commons.math4.legacy.core.RealFieldElement;
import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
@@ -358,7 +358,7 @@
*/
@Override
public Decimal64 remainder(final double a) {
- return new Decimal64(AccurateMath.IEEEremainder(value, a));
+ return new Decimal64(JdkMath.IEEEremainder(value, a));
}
/** {@inheritDoc}
@@ -366,7 +366,7 @@
*/
@Override
public Decimal64 remainder(final Decimal64 a) {
- return new Decimal64(AccurateMath.IEEEremainder(value, a.value));
+ return new Decimal64(JdkMath.IEEEremainder(value, a.value));
}
/** {@inheritDoc}
@@ -374,7 +374,7 @@
*/
@Override
public Decimal64 abs() {
- return new Decimal64(AccurateMath.abs(value));
+ return new Decimal64(JdkMath.abs(value));
}
/** {@inheritDoc}
@@ -382,7 +382,7 @@
*/
@Override
public Decimal64 ceil() {
- return new Decimal64(AccurateMath.ceil(value));
+ return new Decimal64(JdkMath.ceil(value));
}
/** {@inheritDoc}
@@ -390,7 +390,7 @@
*/
@Override
public Decimal64 floor() {
- return new Decimal64(AccurateMath.floor(value));
+ return new Decimal64(JdkMath.floor(value));
}
/** {@inheritDoc}
@@ -398,7 +398,7 @@
*/
@Override
public Decimal64 rint() {
- return new Decimal64(AccurateMath.rint(value));
+ return new Decimal64(JdkMath.rint(value));
}
/** {@inheritDoc}
@@ -406,7 +406,7 @@
*/
@Override
public long round() {
- return AccurateMath.round(value);
+ return JdkMath.round(value);
}
/** {@inheritDoc}
@@ -414,7 +414,7 @@
*/
@Override
public Decimal64 signum() {
- return new Decimal64(AccurateMath.signum(value));
+ return new Decimal64(JdkMath.signum(value));
}
/** {@inheritDoc}
@@ -422,7 +422,7 @@
*/
@Override
public Decimal64 copySign(final Decimal64 sign) {
- return new Decimal64(AccurateMath.copySign(value, sign.value));
+ return new Decimal64(JdkMath.copySign(value, sign.value));
}
/** {@inheritDoc}
@@ -430,7 +430,7 @@
*/
@Override
public Decimal64 copySign(final double sign) {
- return new Decimal64(AccurateMath.copySign(value, sign));
+ return new Decimal64(JdkMath.copySign(value, sign));
}
/** {@inheritDoc}
@@ -438,7 +438,7 @@
*/
@Override
public Decimal64 scalb(final int n) {
- return new Decimal64(AccurateMath.scalb(value, n));
+ return new Decimal64(JdkMath.scalb(value, n));
}
/** {@inheritDoc}
@@ -446,7 +446,7 @@
*/
@Override
public Decimal64 hypot(final Decimal64 y) {
- return new Decimal64(AccurateMath.hypot(value, y.value));
+ return new Decimal64(JdkMath.hypot(value, y.value));
}
/** {@inheritDoc}
@@ -454,7 +454,7 @@
*/
@Override
public Decimal64 sqrt() {
- return new Decimal64(AccurateMath.sqrt(value));
+ return new Decimal64(JdkMath.sqrt(value));
}
/** {@inheritDoc}
@@ -462,7 +462,7 @@
*/
@Override
public Decimal64 cbrt() {
- return new Decimal64(AccurateMath.cbrt(value));
+ return new Decimal64(JdkMath.cbrt(value));
}
/** {@inheritDoc}
@@ -471,9 +471,9 @@
@Override
public Decimal64 rootN(final int n) {
if (value < 0) {
- return new Decimal64(-AccurateMath.pow(-value, 1.0 / n));
+ return new Decimal64(-JdkMath.pow(-value, 1.0 / n));
} else {
- return new Decimal64(AccurateMath.pow(value, 1.0 / n));
+ return new Decimal64(JdkMath.pow(value, 1.0 / n));
}
}
@@ -482,7 +482,7 @@
*/
@Override
public Decimal64 pow(final double p) {
- return new Decimal64(AccurateMath.pow(value, p));
+ return new Decimal64(JdkMath.pow(value, p));
}
/** {@inheritDoc}
@@ -490,7 +490,7 @@
*/
@Override
public Decimal64 pow(final int n) {
- return new Decimal64(AccurateMath.pow(value, n));
+ return new Decimal64(JdkMath.pow(value, n));
}
/** {@inheritDoc}
@@ -498,7 +498,7 @@
*/
@Override
public Decimal64 pow(final Decimal64 e) {
- return new Decimal64(AccurateMath.pow(value, e.value));
+ return new Decimal64(JdkMath.pow(value, e.value));
}
/** {@inheritDoc}
@@ -506,7 +506,7 @@
*/
@Override
public Decimal64 exp() {
- return new Decimal64(AccurateMath.exp(value));
+ return new Decimal64(JdkMath.exp(value));
}
/** {@inheritDoc}
@@ -514,7 +514,7 @@
*/
@Override
public Decimal64 expm1() {
- return new Decimal64(AccurateMath.expm1(value));
+ return new Decimal64(JdkMath.expm1(value));
}
/** {@inheritDoc}
@@ -522,7 +522,7 @@
*/
@Override
public Decimal64 log() {
- return new Decimal64(AccurateMath.log(value));
+ return new Decimal64(JdkMath.log(value));
}
/** {@inheritDoc}
@@ -530,7 +530,7 @@
*/
@Override
public Decimal64 log1p() {
- return new Decimal64(AccurateMath.log1p(value));
+ return new Decimal64(JdkMath.log1p(value));
}
/** Base 10 logarithm.
@@ -539,7 +539,7 @@
*/
@Override
public Decimal64 log10() {
- return new Decimal64(AccurateMath.log10(value));
+ return new Decimal64(JdkMath.log10(value));
}
/** {@inheritDoc}
@@ -547,7 +547,7 @@
*/
@Override
public Decimal64 cos() {
- return new Decimal64(AccurateMath.cos(value));
+ return new Decimal64(JdkMath.cos(value));
}
/** {@inheritDoc}
@@ -555,7 +555,7 @@
*/
@Override
public Decimal64 sin() {
- return new Decimal64(AccurateMath.sin(value));
+ return new Decimal64(JdkMath.sin(value));
}
/** {@inheritDoc}
@@ -563,7 +563,7 @@
*/
@Override
public Decimal64 tan() {
- return new Decimal64(AccurateMath.tan(value));
+ return new Decimal64(JdkMath.tan(value));
}
/** {@inheritDoc}
@@ -571,7 +571,7 @@
*/
@Override
public Decimal64 acos() {
- return new Decimal64(AccurateMath.acos(value));
+ return new Decimal64(JdkMath.acos(value));
}
/** {@inheritDoc}
@@ -579,7 +579,7 @@
*/
@Override
public Decimal64 asin() {
- return new Decimal64(AccurateMath.asin(value));
+ return new Decimal64(JdkMath.asin(value));
}
/** {@inheritDoc}
@@ -587,7 +587,7 @@
*/
@Override
public Decimal64 atan() {
- return new Decimal64(AccurateMath.atan(value));
+ return new Decimal64(JdkMath.atan(value));
}
/** {@inheritDoc}
@@ -595,7 +595,7 @@
*/
@Override
public Decimal64 atan2(final Decimal64 x) {
- return new Decimal64(AccurateMath.atan2(value, x.value));
+ return new Decimal64(JdkMath.atan2(value, x.value));
}
/** {@inheritDoc}
@@ -603,7 +603,7 @@
*/
@Override
public Decimal64 cosh() {
- return new Decimal64(AccurateMath.cosh(value));
+ return new Decimal64(JdkMath.cosh(value));
}
/** {@inheritDoc}
@@ -611,7 +611,7 @@
*/
@Override
public Decimal64 sinh() {
- return new Decimal64(AccurateMath.sinh(value));
+ return new Decimal64(JdkMath.sinh(value));
}
/** {@inheritDoc}
@@ -619,7 +619,7 @@
*/
@Override
public Decimal64 tanh() {
- return new Decimal64(AccurateMath.tanh(value));
+ return new Decimal64(JdkMath.tanh(value));
}
/** {@inheritDoc}
@@ -627,7 +627,7 @@
*/
@Override
public Decimal64 acosh() {
- return new Decimal64(AccurateMath.acosh(value));
+ return new Decimal64(JdkMath.acosh(value));
}
/** {@inheritDoc}
@@ -635,7 +635,7 @@
*/
@Override
public Decimal64 asinh() {
- return new Decimal64(AccurateMath.asinh(value));
+ return new Decimal64(JdkMath.asinh(value));
}
/** {@inheritDoc}
@@ -643,7 +643,7 @@
*/
@Override
public Decimal64 atanh() {
- return new Decimal64(AccurateMath.atanh(value));
+ return new Decimal64(JdkMath.atanh(value));
}
/** {@inheritDoc}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince54IntegratorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince54IntegratorTest.java
index 091b10a..f13a653 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince54IntegratorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince54IntegratorTest.java
@@ -31,7 +31,7 @@
import org.apache.commons.math4.legacy.ode.events.EventHandler;
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;
import org.junit.Assert;
import org.junit.Test;
@@ -80,7 +80,7 @@
TestProblemAbstract pb = new TestProblem5();
double minStep = 1.25;
- double maxStep = AccurateMath.abs(pb.getFinalTime() - pb.getInitialTime());
+ double maxStep = JdkMath.abs(pb.getFinalTime() - pb.getInitialTime());
double scalAbsoluteTolerance = 6.0e-4;
double scalRelativeTolerance = 6.0e-4;
@@ -141,7 +141,7 @@
if (isLast) {
lastSeen = true;
double h = interpolator.getCurrentTime() - interpolator.getPreviousTime();
- Assert.assertTrue(AccurateMath.abs(h) < minStep);
+ Assert.assertTrue(JdkMath.abs(h) < minStep);
}
}
@@ -164,7 +164,7 @@
TestProblem1 pb = new TestProblem1();
double minStep = 0;
double maxStep = pb.getFinalTime() - pb.getInitialTime();
- double scalAbsoluteTolerance = AccurateMath.pow(10.0, i);
+ double scalAbsoluteTolerance = JdkMath.pow(10.0, i);
double scalRelativeTolerance = 0.01 * scalAbsoluteTolerance;
EmbeddedRungeKuttaIntegrator integ =
@@ -332,10 +332,10 @@
public void handleStep(StepInterpolator interpolator,
boolean isLast) {
- double step = AccurateMath.abs(interpolator.getCurrentTime()
+ double step = JdkMath.abs(interpolator.getCurrentTime()
- interpolator.getPreviousTime());
if (firstTime) {
- minStep = AccurateMath.abs(step);
+ minStep = JdkMath.abs(step);
maxStep = minStep;
firstTime = false;
} else {
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince54StepInterpolatorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince54StepInterpolatorTest.java
index 28ec96f..4af338e 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince54StepInterpolatorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince54StepInterpolatorTest.java
@@ -34,7 +34,7 @@
import org.apache.commons.math4.legacy.ode.sampling.StepHandler;
import org.apache.commons.math4.legacy.ode.sampling.StepInterpolator;
import org.apache.commons.math4.legacy.ode.sampling.StepInterpolatorTestUtils;
-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;
@@ -126,13 +126,13 @@
StepInterpolator cloned = interpolator.copy();
double tA = cloned.getPreviousTime();
double tB = cloned.getCurrentTime();
- double halfStep = AccurateMath.abs(tB - tA) / 2;
+ double halfStep = JdkMath.abs(tB - tA) / 2;
Assert.assertEquals(interpolator.getPreviousTime(), tA, 1.0e-12);
Assert.assertEquals(interpolator.getCurrentTime(), tB, 1.0e-12);
for (int i = 0; i < 10; ++i) {
double t = (i * tB + (9 - i) * tA) / 9;
interpolator.setInterpolatedTime(t);
- Assert.assertTrue(AccurateMath.abs(cloned.getInterpolatedTime() - t) > (halfStep / 10));
+ Assert.assertTrue(JdkMath.abs(cloned.getInterpolatedTime() - t) > (halfStep / 10));
cloned.setInterpolatedTime(t);
Assert.assertEquals(t, cloned.getInterpolatedTime(), 1.0e-12);
double[] referenceState = interpolator.getInterpolatedState();
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince853IntegratorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince853IntegratorTest.java
index 5db2ef5..2511e9c 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince853IntegratorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince853IntegratorTest.java
@@ -31,7 +31,7 @@
import org.apache.commons.math4.legacy.ode.events.EventHandler;
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;
import org.junit.Assert;
import org.junit.Test;
@@ -73,7 +73,7 @@
double finalT = integrator.integrate(ode, t0, y0, tEvent, y);
Assert.assertEquals(tEvent, finalT, 5.0e-6);
for (int i = 0; i < y.length; ++i) {
- Assert.assertEquals(y0[i] * AccurateMath.exp(k[i] * (finalT - t0)), y[i], 1.0e-9);
+ Assert.assertEquals(y0[i] * JdkMath.exp(k[i] * (finalT - t0)), y[i], 1.0e-9);
}
integrator.setInitialStepSize(60.0);
@@ -101,7 +101,7 @@
finalT = integrator.integrate(ode, t0, y0, tEvent + 120, y);
Assert.assertEquals(tEvent + 120, finalT, 5.0e-6);
for (int i = 0; i < y.length; ++i) {
- Assert.assertEquals(y0[i] * AccurateMath.exp(k[i] * (finalT - t0)), y[i], 1.0e-9);
+ Assert.assertEquals(y0[i] * JdkMath.exp(k[i] * (finalT - t0)), y[i], 1.0e-9);
}
}
@@ -168,7 +168,7 @@
TestProblem1 pb = new TestProblem1();
double minStep = 0;
double maxStep = pb.getFinalTime() - pb.getInitialTime();
- double scalAbsoluteTolerance = AccurateMath.pow(10.0, i);
+ double scalAbsoluteTolerance = JdkMath.pow(10.0, i);
double scalRelativeTolerance = 0.01 * scalAbsoluteTolerance;
integ.setStepSizeControl(minStep, maxStep, scalAbsoluteTolerance, scalRelativeTolerance);
@@ -211,8 +211,8 @@
@Override
public void computeDerivatives(double t, double[] y, double[] yDot) {
- Assert.assertTrue(t >= AccurateMath.nextAfter(start, Double.NEGATIVE_INFINITY));
- Assert.assertTrue(t <= AccurateMath.nextAfter(end, Double.POSITIVE_INFINITY));
+ Assert.assertTrue(t >= JdkMath.nextAfter(start, Double.NEGATIVE_INFINITY));
+ Assert.assertTrue(t <= JdkMath.nextAfter(end, Double.POSITIVE_INFINITY));
yDot[0] = -100.0 * y[0];
}
@@ -369,7 +369,7 @@
integ.addEventHandler(cosChecker, 0.01, 1.0e-7, 100);
integ.addStepHandler(cosChecker);
double t0 = 0.5;
- double[] y0 = new double[] { AccurateMath.sin(t0), AccurateMath.cos(t0) };
+ double[] y0 = new double[] { JdkMath.sin(t0), JdkMath.cos(t0) };
double t = 10.0;
double[] y = new double[2];
integ.integrate(sincos, t0, y0, t, y);
@@ -471,10 +471,10 @@
public void handleStep(StepInterpolator interpolator,
boolean isLast) {
- double step = AccurateMath.abs(interpolator.getCurrentTime()
+ double step = JdkMath.abs(interpolator.getCurrentTime()
- interpolator.getPreviousTime());
if (firstTime) {
- minStep = AccurateMath.abs(step);
+ minStep = JdkMath.abs(step);
maxStep = minStep;
firstTime = false;
} else {
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince853StepInterpolatorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince853StepInterpolatorTest.java
index 9cce2f5..c45d304 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince853StepInterpolatorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/DormandPrince853StepInterpolatorTest.java
@@ -34,7 +34,7 @@
import org.apache.commons.math4.legacy.ode.sampling.StepHandler;
import org.apache.commons.math4.legacy.ode.sampling.StepInterpolator;
import org.apache.commons.math4.legacy.ode.sampling.StepInterpolatorTestUtils;
-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;
@@ -126,13 +126,13 @@
StepInterpolator cloned = interpolator.copy();
double tA = cloned.getPreviousTime();
double tB = cloned.getCurrentTime();
- double halfStep = AccurateMath.abs(tB - tA) / 2;
+ double halfStep = JdkMath.abs(tB - tA) / 2;
Assert.assertEquals(interpolator.getPreviousTime(), tA, 1.0e-12);
Assert.assertEquals(interpolator.getCurrentTime(), tB, 1.0e-12);
for (int i = 0; i < 10; ++i) {
double t = (i * tB + (9 - i) * tA) / 9;
interpolator.setInterpolatedTime(t);
- Assert.assertTrue(AccurateMath.abs(cloned.getInterpolatedTime() - t) > (halfStep / 10));
+ Assert.assertTrue(JdkMath.abs(cloned.getInterpolatedTime() - t) > (halfStep / 10));
cloned.setInterpolatedTime(t);
Assert.assertEquals(t, cloned.getInterpolatedTime(), 1.0e-12);
double[] referenceState = interpolator.getInterpolatedState();
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/EmbeddedRungeKuttaFieldIntegratorAbstractTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/EmbeddedRungeKuttaFieldIntegratorAbstractTest.java
index 82b21b3..34f6465 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/EmbeddedRungeKuttaFieldIntegratorAbstractTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/EmbeddedRungeKuttaFieldIntegratorAbstractTest.java
@@ -39,7 +39,7 @@
import org.apache.commons.math4.legacy.ode.events.FieldEventHandler;
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;
import org.junit.Assert;
import org.junit.Test;
@@ -122,7 +122,7 @@
if (regularArray[i] == 0) {
Assert.assertEquals(0.0, fieldArray[i].getReal(), 0.0);
} else {
- Assert.assertEquals(regularArray[i], fieldArray[i].getReal(), AccurateMath.ulp(regularArray[i]));
+ Assert.assertEquals(regularArray[i], fieldArray[i].getReal(), JdkMath.ulp(regularArray[i]));
}
}
}
@@ -212,7 +212,7 @@
TestFieldProblem1<T> pb = new TestFieldProblem1<>(field);
double minStep = 0;
double maxStep = pb.getFinalTime().subtract(pb.getInitialState().getTime()).getReal();
- double scalAbsoluteTolerance = AccurateMath.pow(10.0, i);
+ double scalAbsoluteTolerance = JdkMath.pow(10.0, i);
double scalRelativeTolerance = 0.01 * scalAbsoluteTolerance;
FirstOrderFieldIntegrator<T> integ = createIntegrator(field, minStep, maxStep,
@@ -577,7 +577,7 @@
public double[] theoreticalY(final double t) {
final double theta = omega.getReal() * t + alpha.getReal();
return new double[] {
- r.getReal() * AccurateMath.sin(theta), r.getReal() * AccurateMath.cos(theta)
+ r.getReal() * JdkMath.sin(theta), r.getReal() * JdkMath.cos(theta)
};
}
@@ -585,8 +585,8 @@
// intermediate angle and state
final double theta = omega.getReal() * t + alpha.getReal();
- final double sin = AccurateMath.sin(theta);
- final double cos = AccurateMath.cos(theta);
+ final double sin = JdkMath.sin(theta);
+ final double cos = JdkMath.cos(theta);
final double y0 = r.getReal() * sin;
final double y1 = r.getReal() * cos;
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/EulerIntegratorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/EulerIntegratorTest.java
index 264e3e6..76ea607 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/EulerIntegratorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/EulerIntegratorTest.java
@@ -35,7 +35,7 @@
import org.apache.commons.math4.legacy.ode.events.EventHandler;
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;
import org.junit.Assert;
import org.junit.Test;
@@ -66,7 +66,7 @@
double previousTimeError = Double.NaN;
for (int i = 4; i < 8; ++i) {
- double step = (pb.getFinalTime() - pb.getInitialTime()) * AccurateMath.pow(2.0, -i);
+ double step = (pb.getFinalTime() - pb.getInitialTime()) * JdkMath.pow(2.0, -i);
FirstOrderIntegrator integ = new EulerIntegrator(step);
TestProblemHandler handler = new TestProblemHandler(pb, integ);
@@ -84,13 +84,13 @@
double valueError = handler.getMaximalValueError();
if (i > 4) {
- Assert.assertTrue(valueError < AccurateMath.abs(previousValueError));
+ Assert.assertTrue(valueError < JdkMath.abs(previousValueError));
}
previousValueError = valueError;
double timeError = handler.getMaximalTimeError();
if (i > 4) {
- Assert.assertTrue(timeError <= AccurateMath.abs(previousTimeError));
+ Assert.assertTrue(timeError <= JdkMath.abs(previousTimeError));
}
previousTimeError = timeError;
@@ -149,7 +149,7 @@
MaxCountExceededException, NoBracketingException {
TestProblem5 pb = new TestProblem5();
- double step = AccurateMath.abs(pb.getFinalTime() - pb.getInitialTime()) * 0.001;
+ double step = JdkMath.abs(pb.getFinalTime() - pb.getInitialTime()) * 0.001;
FirstOrderIntegrator integ = new EulerIntegrator(step);
TestProblemHandler handler = new TestProblemHandler(pb, integ);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/EulerStepInterpolatorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/EulerStepInterpolatorTest.java
index ed78095..6f2a719 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/EulerStepInterpolatorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/EulerStepInterpolatorTest.java
@@ -35,7 +35,7 @@
import org.apache.commons.math4.legacy.ode.TestProblem3;
import org.apache.commons.math4.legacy.ode.sampling.StepHandler;
import org.apache.commons.math4.legacy.ode.sampling.StepInterpolatorTestUtils;
-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,7 +56,7 @@
double[] result = interpolator.getInterpolatedState();
for (int i = 0; i < result.length; ++i) {
- Assert.assertTrue(AccurateMath.abs(result[i] - y[i]) < 1.0e-10);
+ Assert.assertTrue(JdkMath.abs(result[i] - y[i]) < 1.0e-10);
}
}
@@ -88,13 +88,13 @@
interpolator.setInterpolatedTime(interpolator.getPreviousTime());
double[] result = interpolator.getInterpolatedState();
for (int i = 0; i < result.length; ++i) {
- Assert.assertTrue(AccurateMath.abs(result[i] - y0[i]) < 1.0e-10);
+ Assert.assertTrue(JdkMath.abs(result[i] - y0[i]) < 1.0e-10);
}
interpolator.setInterpolatedTime(interpolator.getCurrentTime());
result = interpolator.getInterpolatedState();
for (int i = 0; i < result.length; ++i) {
- Assert.assertTrue(AccurateMath.abs(result[i] - y[i]) < 1.0e-10);
+ Assert.assertTrue(JdkMath.abs(result[i] - y[i]) < 1.0e-10);
}
}
@@ -117,15 +117,15 @@
interpolator.setInterpolatedTime(0.1);
double[] result = interpolator.getInterpolatedState();
- Assert.assertTrue(AccurateMath.abs(result[0] - 0.1) < 1.0e-10);
- Assert.assertTrue(AccurateMath.abs(result[1] - 1.2) < 1.0e-10);
- Assert.assertTrue(AccurateMath.abs(result[2] + 2.2) < 1.0e-10);
+ Assert.assertTrue(JdkMath.abs(result[0] - 0.1) < 1.0e-10);
+ Assert.assertTrue(JdkMath.abs(result[1] - 1.2) < 1.0e-10);
+ Assert.assertTrue(JdkMath.abs(result[2] + 2.2) < 1.0e-10);
interpolator.setInterpolatedTime(0.5);
result = interpolator.getInterpolatedState();
- Assert.assertTrue(AccurateMath.abs(result[0] - 0.5) < 1.0e-10);
- Assert.assertTrue(AccurateMath.abs(result[1] - 2.0) < 1.0e-10);
- Assert.assertTrue(AccurateMath.abs(result[2] + 3.0) < 1.0e-10);
+ Assert.assertTrue(JdkMath.abs(result[0] - 0.5) < 1.0e-10);
+ Assert.assertTrue(JdkMath.abs(result[1] - 2.0) < 1.0e-10);
+ Assert.assertTrue(JdkMath.abs(result[2] + 3.0) < 1.0e-10);
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/GillIntegratorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/GillIntegratorTest.java
index 5b91e41..f65fc34 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/GillIntegratorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/GillIntegratorTest.java
@@ -35,7 +35,7 @@
import org.apache.commons.math4.legacy.ode.events.EventHandler;
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;
import org.junit.Assert;
import org.junit.Test;
@@ -66,7 +66,7 @@
double previousTimeError = Double.NaN;
for (int i = 5; i < 10; ++i) {
- double step = (pb.getFinalTime() - pb.getInitialTime()) * AccurateMath.pow(2.0, -i);
+ double step = (pb.getFinalTime() - pb.getInitialTime()) * JdkMath.pow(2.0, -i);
FirstOrderIntegrator integ = new GillIntegrator(step);
TestProblemHandler handler = new TestProblemHandler(pb, integ);
@@ -84,13 +84,13 @@
double valueError = handler.getMaximalValueError();
if (i > 5) {
- Assert.assertTrue(valueError < 1.01 * AccurateMath.abs(previousValueError));
+ Assert.assertTrue(valueError < 1.01 * JdkMath.abs(previousValueError));
}
previousValueError = valueError;
double timeError = handler.getMaximalTimeError();
if (i > 5) {
- Assert.assertTrue(timeError <= AccurateMath.abs(previousTimeError));
+ Assert.assertTrue(timeError <= JdkMath.abs(previousTimeError));
}
previousTimeError = timeError;
@@ -147,7 +147,7 @@
MaxCountExceededException, NoBracketingException {
TestProblem5 pb = new TestProblem5();
- double step = AccurateMath.abs(pb.getFinalTime() - pb.getInitialTime()) * 0.001;
+ double step = JdkMath.abs(pb.getFinalTime() - pb.getInitialTime()) * 0.001;
FirstOrderIntegrator integ = new GillIntegrator(step);
TestProblemHandler handler = new TestProblemHandler(pb, integ);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/GraggBulirschStoerIntegratorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/GraggBulirschStoerIntegratorTest.java
index f2c64cf..6f6ed4b 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/GraggBulirschStoerIntegratorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/GraggBulirschStoerIntegratorTest.java
@@ -32,7 +32,7 @@
import org.apache.commons.math4.legacy.ode.events.EventHandler;
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;
import org.junit.Assert;
import org.junit.Test;
@@ -69,8 +69,8 @@
MaxCountExceededException, NoBracketingException {
TestProblem5 pb = new TestProblem5();
- double minStep = 0.1 * AccurateMath.abs(pb.getFinalTime() - pb.getInitialTime());
- double maxStep = AccurateMath.abs(pb.getFinalTime() - pb.getInitialTime());
+ double minStep = 0.1 * JdkMath.abs(pb.getFinalTime() - pb.getInitialTime());
+ double maxStep = JdkMath.abs(pb.getFinalTime() - pb.getInitialTime());
double[] vecAbsoluteTolerance = { 1.0e-20, 1.0e-21 };
double[] vecRelativeTolerance = { 1.0e-20, 1.0e-21 };
@@ -120,7 +120,7 @@
TestProblem1 pb = new TestProblem1();
double minStep = 0;
double maxStep = pb.getFinalTime() - pb.getInitialTime();
- double absTolerance = AccurateMath.pow(10.0, i);
+ double absTolerance = JdkMath.pow(10.0, i);
double relTolerance = absTolerance;
FirstOrderIntegrator integ =
@@ -288,8 +288,8 @@
@Override
public void computeDerivatives(double t, double[] y, double[] yDot) {
- Assert.assertTrue(t >= AccurateMath.nextAfter(start, Double.NEGATIVE_INFINITY));
- Assert.assertTrue(t <= AccurateMath.nextAfter(end, Double.POSITIVE_INFINITY));
+ Assert.assertTrue(t >= JdkMath.nextAfter(start, Double.NEGATIVE_INFINITY));
+ Assert.assertTrue(t <= JdkMath.nextAfter(end, Double.POSITIVE_INFINITY));
yDot[0] = -100.0 * y[0];
}
@@ -408,10 +408,10 @@
public void handleStep(StepInterpolator interpolator,
boolean isLast) {
- double step = AccurateMath.abs(interpolator.getCurrentTime()
+ double step = JdkMath.abs(interpolator.getCurrentTime()
- interpolator.getPreviousTime());
if (firstTime) {
- minStep = AccurateMath.abs(step);
+ minStep = JdkMath.abs(step);
maxStep = minStep;
firstTime = false;
} else {
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/GraggBulirschStoerStepInterpolatorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/GraggBulirschStoerStepInterpolatorTest.java
index 3fe2e49..0f9b1ba 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/GraggBulirschStoerStepInterpolatorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/GraggBulirschStoerStepInterpolatorTest.java
@@ -34,7 +34,7 @@
import org.apache.commons.math4.legacy.ode.sampling.StepHandler;
import org.apache.commons.math4.legacy.ode.sampling.StepInterpolator;
import org.apache.commons.math4.legacy.ode.sampling.StepInterpolatorTestUtils;
-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;
@@ -128,13 +128,13 @@
StepInterpolator cloned = interpolator.copy();
double tA = cloned.getPreviousTime();
double tB = cloned.getCurrentTime();
- double halfStep = AccurateMath.abs(tB - tA) / 2;
+ double halfStep = JdkMath.abs(tB - tA) / 2;
Assert.assertEquals(interpolator.getPreviousTime(), tA, 1.0e-12);
Assert.assertEquals(interpolator.getCurrentTime(), tB, 1.0e-12);
for (int i = 0; i < 10; ++i) {
double t = (i * tB + (9 - i) * tA) / 9;
interpolator.setInterpolatedTime(t);
- Assert.assertTrue(AccurateMath.abs(cloned.getInterpolatedTime() - t) > (halfStep / 10));
+ Assert.assertTrue(JdkMath.abs(cloned.getInterpolatedTime() - t) > (halfStep / 10));
cloned.setInterpolatedTime(t);
Assert.assertEquals(t, cloned.getInterpolatedTime(), 1.0e-12);
double[] referenceState = interpolator.getInterpolatedState();
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/HighamHall54IntegratorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/HighamHall54IntegratorTest.java
index 8be5067..3ed14b3 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/HighamHall54IntegratorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/HighamHall54IntegratorTest.java
@@ -31,7 +31,7 @@
import org.apache.commons.math4.legacy.ode.TestProblem5;
import org.apache.commons.math4.legacy.ode.TestProblemHandler;
import org.apache.commons.math4.legacy.ode.events.EventHandler;
-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;
@@ -108,7 +108,7 @@
TestProblem1 pb = new TestProblem1();
double minStep = 0;
double maxStep = pb.getFinalTime() - pb.getInitialTime();
- double scalAbsoluteTolerance = AccurateMath.pow(10.0, i);
+ double scalAbsoluteTolerance = JdkMath.pow(10.0, i);
double scalRelativeTolerance = 0.01 * scalAbsoluteTolerance;
FirstOrderIntegrator integ = new HighamHall54Integrator(minStep, maxStep,
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/HighamHall54StepInterpolatorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/HighamHall54StepInterpolatorTest.java
index 13af17f..cc6e912 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/HighamHall54StepInterpolatorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/HighamHall54StepInterpolatorTest.java
@@ -34,7 +34,7 @@
import org.apache.commons.math4.legacy.ode.sampling.StepHandler;
import org.apache.commons.math4.legacy.ode.sampling.StepInterpolator;
import org.apache.commons.math4.legacy.ode.sampling.StepInterpolatorTestUtils;
-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;
@@ -126,13 +126,13 @@
StepInterpolator cloned = interpolator.copy();
double tA = cloned.getPreviousTime();
double tB = cloned.getCurrentTime();
- double halfStep = AccurateMath.abs(tB - tA) / 2;
+ double halfStep = JdkMath.abs(tB - tA) / 2;
Assert.assertEquals(interpolator.getPreviousTime(), tA, 1.0e-12);
Assert.assertEquals(interpolator.getCurrentTime(), tB, 1.0e-12);
for (int i = 0; i < 10; ++i) {
double t = (i * tB + (9 - i) * tA) / 9;
interpolator.setInterpolatedTime(t);
- Assert.assertTrue(AccurateMath.abs(cloned.getInterpolatedTime() - t) > (halfStep / 10));
+ Assert.assertTrue(JdkMath.abs(cloned.getInterpolatedTime() - t) > (halfStep / 10));
cloned.setInterpolatedTime(t);
Assert.assertEquals(t, cloned.getInterpolatedTime(), 1.0e-12);
double[] referenceState = interpolator.getInterpolatedState();
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/LutherIntegratorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/LutherIntegratorTest.java
index 346a22c..e0f165b 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/LutherIntegratorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/LutherIntegratorTest.java
@@ -35,7 +35,7 @@
import org.apache.commons.math4.legacy.ode.events.EventHandler;
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;
import org.junit.Assert;
import org.junit.Test;
@@ -74,7 +74,7 @@
double finalT = integrator.integrate(ode, t0, y0, tEvent, y);
Assert.assertEquals(tEvent, finalT, 1.0e-15);
for (int i = 0; i < y.length; ++i) {
- Assert.assertEquals(y0[i] * AccurateMath.exp(k[i] * (finalT - t0)), y[i], 1.0e-15);
+ Assert.assertEquals(y0[i] * JdkMath.exp(k[i] * (finalT - t0)), y[i], 1.0e-15);
}
integrator.addEventHandler(new EventHandler() {
@@ -101,7 +101,7 @@
finalT = integrator.integrate(ode, t0, y0, tEvent + 120, y);
Assert.assertEquals(tEvent + 120, finalT, 1.0e-15);
for (int i = 0; i < y.length; ++i) {
- Assert.assertEquals(y0[i] * AccurateMath.exp(k[i] * (finalT - t0)), y[i], 1.0e-15);
+ Assert.assertEquals(y0[i] * JdkMath.exp(k[i] * (finalT - t0)), y[i], 1.0e-15);
}
}
@@ -150,7 +150,7 @@
double previousTimeError = Double.NaN;
for (int i = 4; i < 10; ++i) {
- double step = (pb.getFinalTime() - pb.getInitialTime()) * AccurateMath.pow(2.0, -i);
+ double step = (pb.getFinalTime() - pb.getInitialTime()) * JdkMath.pow(2.0, -i);
FirstOrderIntegrator integ = new LutherIntegrator(step);
TestProblemHandler handler = new TestProblemHandler(pb, integ);
@@ -169,13 +169,13 @@
double error = handler.getMaximalValueError();
if (i > 4) {
- Assert.assertTrue(error < 1.01 * AccurateMath.abs(previousValueError));
+ Assert.assertTrue(error < 1.01 * JdkMath.abs(previousValueError));
}
previousValueError = error;
double timeError = handler.getMaximalTimeError();
if (i > 4) {
- Assert.assertTrue(timeError <= AccurateMath.abs(previousTimeError));
+ Assert.assertTrue(timeError <= JdkMath.abs(previousTimeError));
}
previousTimeError = timeError;
@@ -233,7 +233,7 @@
MaxCountExceededException, NoBracketingException {
TestProblem5 pb = new TestProblem5();
- double step = AccurateMath.abs(pb.getFinalTime() - pb.getInitialTime()) * 0.001;
+ double step = JdkMath.abs(pb.getFinalTime() - pb.getInitialTime()) * 0.001;
FirstOrderIntegrator integ = new LutherIntegrator(step);
TestProblemHandler handler = new TestProblemHandler(pb, integ);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/MidpointIntegratorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/MidpointIntegratorTest.java
index 4fd7e95..6fea0a3 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/MidpointIntegratorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/MidpointIntegratorTest.java
@@ -35,7 +35,7 @@
import org.apache.commons.math4.legacy.ode.events.EventHandler;
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;
import org.junit.Assert;
import org.junit.Test;
@@ -66,7 +66,7 @@
double previousTimeError = Double.NaN;
for (int i = 4; i < 10; ++i) {
- double step = (pb.getFinalTime() - pb.getInitialTime()) * AccurateMath.pow(2.0, -i);
+ double step = (pb.getFinalTime() - pb.getInitialTime()) * JdkMath.pow(2.0, -i);
FirstOrderIntegrator integ = new MidpointIntegrator(step);
TestProblemHandler handler = new TestProblemHandler(pb, integ);
integ.addStepHandler(handler);
@@ -84,13 +84,13 @@
double valueError = handler.getMaximalValueError();
if (i > 4) {
- Assert.assertTrue(valueError < AccurateMath.abs(previousValueError));
+ Assert.assertTrue(valueError < JdkMath.abs(previousValueError));
}
previousValueError = valueError;
double timeError = handler.getMaximalTimeError();
if (i > 4) {
- Assert.assertTrue(timeError <= AccurateMath.abs(previousTimeError));
+ Assert.assertTrue(timeError <= JdkMath.abs(previousTimeError));
}
previousTimeError = timeError;
@@ -149,7 +149,7 @@
MaxCountExceededException, NoBracketingException {
TestProblem5 pb = new TestProblem5();
- double step = AccurateMath.abs(pb.getFinalTime() - pb.getInitialTime()) * 0.001;
+ double step = JdkMath.abs(pb.getFinalTime() - pb.getInitialTime()) * 0.001;
FirstOrderIntegrator integ = new MidpointIntegrator(step);
TestProblemHandler handler = new TestProblemHandler(pb, integ);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/RungeKuttaFieldIntegratorAbstractTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/RungeKuttaFieldIntegratorAbstractTest.java
index 26d56d8..ce75ae2 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/RungeKuttaFieldIntegratorAbstractTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/RungeKuttaFieldIntegratorAbstractTest.java
@@ -44,7 +44,7 @@
import org.apache.commons.math4.legacy.ode.sampling.FieldStepHandler;
import org.apache.commons.math4.legacy.ode.sampling.FieldStepInterpolator;
import org.apache.commons.math4.legacy.ode.sampling.StepInterpolatorTestUtils;
-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.junit.Assert;
import org.junit.Test;
@@ -108,7 +108,7 @@
if (regularArray[i] == 0) {
Assert.assertEquals(0.0, fieldArray[i].getReal(), 0.0);
} else {
- Assert.assertEquals(regularArray[i], fieldArray[i].getReal(), AccurateMath.ulp(regularArray[i]));
+ Assert.assertEquals(regularArray[i], fieldArray[i].getReal(), JdkMath.ulp(regularArray[i]));
}
}
}
@@ -250,7 +250,7 @@
T previousTimeError = null;
for (int i = 4; i < 10; ++i) {
- T step = pb.getFinalTime().subtract(pb.getInitialState().getTime()).multiply(AccurateMath.pow(2.0, -i));
+ T step = pb.getFinalTime().subtract(pb.getInitialState().getTime()).multiply(JdkMath.pow(2.0, -i));
RungeKuttaFieldIntegrator<T> integ = createIntegrator(field, step);
TestFieldProblemHandler<T> handler = new TestFieldProblemHandler<>(pb, integ);
@@ -497,8 +497,8 @@
@Override
public T[] computeDerivatives(T t, T[] y) {
- Assert.assertTrue(t.getReal() >= AccurateMath.nextAfter(t0.getReal(), Double.NEGATIVE_INFINITY));
- Assert.assertTrue(t.getReal() <= AccurateMath.nextAfter(t.getReal(), Double.POSITIVE_INFINITY));
+ Assert.assertTrue(t.getReal() >= JdkMath.nextAfter(t0.getReal(), Double.NEGATIVE_INFINITY));
+ Assert.assertTrue(t.getReal() <= JdkMath.nextAfter(t.getReal(), Double.POSITIVE_INFINITY));
T[] yDot = MathArrays.buildArray(field, 1);
yDot[0] = y[0].multiply(-100.0);
return yDot;
@@ -643,7 +643,7 @@
public double[] theoreticalY(final double t) {
final double theta = omega.getReal() * t + alpha.getReal();
return new double[] {
- r.getReal() * AccurateMath.sin(theta), r.getReal() * AccurateMath.cos(theta)
+ r.getReal() * JdkMath.sin(theta), r.getReal() * JdkMath.cos(theta)
};
}
@@ -651,8 +651,8 @@
// intermediate angle and state
final double theta = omega.getReal() * t + alpha.getReal();
- final double sin = AccurateMath.sin(theta);
- final double cos = AccurateMath.cos(theta);
+ final double sin = JdkMath.sin(theta);
+ final double cos = JdkMath.cos(theta);
final double y0 = r.getReal() * sin;
final double y1 = r.getReal() * cos;
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/RungeKuttaFieldStepInterpolatorAbstractTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/RungeKuttaFieldStepInterpolatorAbstractTest.java
index 114c430..cc951b3 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/RungeKuttaFieldStepInterpolatorAbstractTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/RungeKuttaFieldStepInterpolatorAbstractTest.java
@@ -28,7 +28,7 @@
import org.apache.commons.math4.legacy.ode.FirstOrderFieldDifferentialEquations;
import org.apache.commons.math4.legacy.ode.FieldODEStateAndDerivative;
import org.apache.commons.math4.legacy.ode.sampling.AbstractFieldStepInterpolator;
-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.junit.Assert;
import org.junit.Test;
@@ -88,8 +88,8 @@
add(interpolator.getCurrentState().getTime().multiply(i)).
divide(n);
FieldODEStateAndDerivative<T> state = interpolator.getInterpolatedState(t);
- maxErrorSin = AccurateMath.max(maxErrorSin, state.getState()[0].subtract(t.sin()).abs().getReal());
- maxErrorCos = AccurateMath.max(maxErrorCos, state.getState()[1].subtract(t.cos()).abs().getReal());
+ maxErrorSin = JdkMath.max(maxErrorSin, state.getState()[0].subtract(t.sin()).abs().getReal());
+ maxErrorCos = JdkMath.max(maxErrorCos, state.getState()[1].subtract(t.cos()).abs().getReal());
}
Assert.assertEquals(0.0, maxErrorSin, epsilonSin);
Assert.assertEquals(0.0, maxErrorCos, epsilonCos);
@@ -127,10 +127,10 @@
double[] regularY = regularInterpolator.getInterpolatedState();
double[] regularYDot = regularInterpolator.getInterpolatedDerivatives();
- maxErrorSin = AccurateMath.max(maxErrorSin, fieldY[0].subtract(regularY[0]).abs().getReal());
- maxErrorCos = AccurateMath.max(maxErrorCos, fieldY[1].subtract(regularY[1]).abs().getReal());
- maxErrorSinDot = AccurateMath.max(maxErrorSinDot, fieldYDot[0].subtract(regularYDot[0]).abs().getReal());
- maxErrorCosDot = AccurateMath.max(maxErrorCosDot, fieldYDot[1].subtract(regularYDot[1]).abs().getReal());
+ maxErrorSin = JdkMath.max(maxErrorSin, fieldY[0].subtract(regularY[0]).abs().getReal());
+ maxErrorCos = JdkMath.max(maxErrorCos, fieldY[1].subtract(regularY[1]).abs().getReal());
+ maxErrorSinDot = JdkMath.max(maxErrorSinDot, fieldYDot[0].subtract(regularYDot[0]).abs().getReal());
+ maxErrorCosDot = JdkMath.max(maxErrorCosDot, fieldYDot[1].subtract(regularYDot[1]).abs().getReal());
}
Assert.assertEquals(0.0, maxErrorSin, epsilonSin);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/ThreeEighthesIntegratorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/ThreeEighthesIntegratorTest.java
index 1a1b89e..6b142b1 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/ThreeEighthesIntegratorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/nonstiff/ThreeEighthesIntegratorTest.java
@@ -35,7 +35,7 @@
import org.apache.commons.math4.legacy.ode.events.EventHandler;
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;
import org.junit.Assert;
import org.junit.Test;
@@ -66,7 +66,7 @@
double previousTimeError = Double.NaN;
for (int i = 4; i < 10; ++i) {
- double step = (pb.getFinalTime() - pb.getInitialTime()) * AccurateMath.pow(2.0, -i);
+ double step = (pb.getFinalTime() - pb.getInitialTime()) * JdkMath.pow(2.0, -i);
FirstOrderIntegrator integ = new ThreeEighthesIntegrator(step);
TestProblemHandler handler = new TestProblemHandler(pb, integ);
@@ -84,13 +84,13 @@
double error = handler.getMaximalValueError();
if (i > 4) {
- Assert.assertTrue(error < 1.01 * AccurateMath.abs(previousValueError));
+ Assert.assertTrue(error < 1.01 * JdkMath.abs(previousValueError));
}
previousValueError = error;
double timeError = handler.getMaximalTimeError();
if (i > 4) {
- Assert.assertTrue(timeError <= AccurateMath.abs(previousTimeError));
+ Assert.assertTrue(timeError <= JdkMath.abs(previousTimeError));
}
previousTimeError = timeError;
@@ -147,7 +147,7 @@
MaxCountExceededException, NoBracketingException {
TestProblem5 pb = new TestProblem5();
- double step = AccurateMath.abs(pb.getFinalTime() - pb.getInitialTime()) * 0.001;
+ double step = JdkMath.abs(pb.getFinalTime() - pb.getInitialTime()) * 0.001;
FirstOrderIntegrator integ = new ThreeEighthesIntegrator(step);
TestProblemHandler handler = new TestProblemHandler(pb, integ);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/sampling/DummyStepInterpolatorTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/sampling/DummyStepInterpolatorTest.java
index c459035..fdaeced 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/sampling/DummyStepInterpolatorTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/sampling/DummyStepInterpolatorTest.java
@@ -25,7 +25,7 @@
import java.io.ObjectOutputStream;
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.junit.Assert;
import org.junit.Test;
@@ -42,7 +42,7 @@
double[] result = interpolator.getInterpolatedState();
for (int i = 0; i < result.length; ++i) {
- Assert.assertTrue(AccurateMath.abs(result[i] - y[i]) < 1.0e-10);
+ Assert.assertTrue(JdkMath.abs(result[i] - y[i]) < 1.0e-10);
}
}
@@ -59,13 +59,13 @@
interpolator.setInterpolatedTime(0.1);
double[] result = interpolator.getInterpolatedState();
for (int i = 0; i < result.length; ++i) {
- Assert.assertTrue(AccurateMath.abs(result[i] - y[i]) < 1.0e-10);
+ Assert.assertTrue(JdkMath.abs(result[i] - y[i]) < 1.0e-10);
}
interpolator.setInterpolatedTime(0.5);
result = interpolator.getInterpolatedState();
for (int i = 0; i < result.length; ++i) {
- Assert.assertTrue(AccurateMath.abs(result[i] - y[i]) < 1.0e-10);
+ Assert.assertTrue(JdkMath.abs(result[i] - y[i]) < 1.0e-10);
}
}
@@ -94,7 +94,7 @@
dsi.setInterpolatedTime(0.5);
double[] result = dsi.getInterpolatedState();
for (int i = 0; i < result.length; ++i) {
- Assert.assertTrue(AccurateMath.abs(result[i] - y[i]) < 1.0e-10);
+ Assert.assertTrue(JdkMath.abs(result[i] - y[i]) < 1.0e-10);
}
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/sampling/StepInterpolatorTestUtils.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/sampling/StepInterpolatorTestUtils.java
index 75f3329..54960d6 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/sampling/StepInterpolatorTestUtils.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/sampling/StepInterpolatorTestUtils.java
@@ -28,7 +28,7 @@
import org.apache.commons.math4.legacy.ode.FirstOrderIntegrator;
import org.apache.commons.math4.legacy.ode.TestFieldProblemAbstract;
import org.apache.commons.math4.legacy.ode.TestProblemAbstract;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
import org.junit.Assert;
public final class StepInterpolatorTestUtils {
@@ -52,7 +52,7 @@
final double h = finiteDifferencesRatio * dt;
final double t = interpolator.getCurrentTime() - 0.3 * dt;
- if (AccurateMath.abs(h) < 10 * AccurateMath.ulp(t)) {
+ if (JdkMath.abs(h) < 10 * JdkMath.ulp(t)) {
return;
}
@@ -110,7 +110,7 @@
final T h = interpolator.getCurrentState().getTime().subtract(interpolator.getPreviousState().getTime()).multiply(0.001);
final T t = interpolator.getCurrentState().getTime().subtract(h.multiply(300));
- if (h.abs().subtract(AccurateMath.ulp(t.getReal()) * 10).getReal() < 0) {
+ if (h.abs().subtract(JdkMath.ulp(t.getReal()) * 10).getReal() < 0) {
return;
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/sampling/StepNormalizerTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/sampling/StepNormalizerTest.java
index 1f9bde4..3b1cdd5 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/sampling/StepNormalizerTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/ode/sampling/StepNormalizerTest.java
@@ -24,7 +24,7 @@
import org.apache.commons.math4.legacy.ode.FirstOrderIntegrator;
import org.apache.commons.math4.legacy.ode.TestProblem3;
import org.apache.commons.math4.legacy.ode.nonstiff.DormandPrince54Integrator;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
@@ -101,7 +101,7 @@
}
public void checkValue(double value, double reference) {
- Assert.assertTrue(AccurateMath.abs(value - reference) < 1.0e-10);
+ Assert.assertTrue(JdkMath.abs(value - reference) < 1.0e-10);
}
public void setLastSeen(boolean lastSeen) {
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/CMAESOptimizerTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/CMAESOptimizerTest.java
index 7481adc..830b753 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/CMAESOptimizerTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/CMAESOptimizerTest.java
@@ -31,7 +31,7 @@
import org.apache.commons.math4.legacy.optim.nonlinear.scalar.ObjectiveFunction;
import org.apache.commons.math4.legacy.optim.nonlinear.scalar.TestFunction;
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;
@@ -41,7 +41,7 @@
public class CMAESOptimizerTest {
static final int DIM = 13;
- static final int LAMBDA = 4 + (int)(3.*AccurateMath.log(DIM));
+ static final int LAMBDA = 4 + (int)(3.*JdkMath.log(DIM));
@Test(expected = NumberIsTooLargeException.class)
public void testInitOutofbounds1() {
@@ -338,10 +338,10 @@
PointValuePair expected =
new PointValuePair(OptimTestUtils.point(DIM,0.0),0.0);
doTest(TestFunction.RASTRIGIN.withDimension(DIM), startPoint, insigma, boundaries,
- GoalType.MINIMIZE, (int)(200*AccurateMath.sqrt(DIM)), true, 0, 1e-13,
+ GoalType.MINIMIZE, (int)(200*JdkMath.sqrt(DIM)), true, 0, 1e-13,
1e-13, 1e-6, 200000, expected);
doTest(TestFunction.RASTRIGIN.withDimension(DIM), startPoint, insigma, boundaries,
- GoalType.MINIMIZE, (int)(200*AccurateMath.sqrt(DIM)), false, 0, 1e-13,
+ GoalType.MINIMIZE, (int)(200*JdkMath.sqrt(DIM)), false, 0, 1e-13,
1e-13, 1e-6, 200000, expected);
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/OptimTestUtils.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/OptimTestUtils.java
index 46837fb..f0962ee 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/OptimTestUtils.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/OptimTestUtils.java
@@ -23,7 +23,7 @@
import org.apache.commons.rng.sampling.distribution.MarsagliaNormalizedGaussianSampler;
import org.apache.commons.rng.sampling.distribution.ContinuousUniformSampler;
import org.apache.commons.math4.legacy.analysis.MultivariateFunction;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
/**
* Utilities for testing the optimizers.
@@ -51,7 +51,7 @@
double f = 0;
x = B.Rotate(x);
for (int i = 0; i < x.length; ++i) {
- f += AccurateMath.pow(factor, i / (x.length - 1.)) * x[i] * x[i];
+ f += JdkMath.pow(factor, i / (x.length - 1.)) * x[i] * x[i];
}
return f;
}
@@ -73,7 +73,7 @@
final double x = variables[0];
final double y = variables[1];
return (x == 0 || y == 0) ? 0 :
- AccurateMath.atan(x) * AccurateMath.atan(x + 2) * AccurateMath.atan(y) * AccurateMath.atan(y) / (x * y);
+ JdkMath.atan(x) * JdkMath.atan(x + 2) * JdkMath.atan(y) * JdkMath.atan(y) / (x * y);
}
}
@@ -164,7 +164,7 @@
sp += basis[i][k] * basis[i][k]; /* squared norm */
}
for (k = 0; k < dim; ++k) {
- basis[i][k] /= AccurateMath.sqrt(sp);
+ basis[i][k] /= JdkMath.sqrt(sp);
}
}
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/PowellOptimizerTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/PowellOptimizerTest.java
index 89301b3..f040062 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/PowellOptimizerTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/PowellOptimizerTest.java
@@ -25,7 +25,7 @@
import org.apache.commons.math4.legacy.optim.SimpleBounds;
import org.apache.commons.math4.legacy.optim.nonlinear.scalar.GoalType;
import org.apache.commons.math4.legacy.optim.nonlinear.scalar.ObjectiveFunction;
-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;
@@ -153,7 +153,7 @@
public double value(double[] x) {
final double a = x[0] - 1;
final double b = x[1] - 1;
- return a * a * AccurateMath.sqrt(AccurateMath.abs(a)) + b * b + 1;
+ return a * a * JdkMath.sqrt(JdkMath.abs(a)) + b * b + 1;
}
};
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/SimplexOptimizerMultiDirectionalTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/SimplexOptimizerMultiDirectionalTest.java
index 18ec771..cab242d 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/SimplexOptimizerMultiDirectionalTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/nonlinear/scalar/noderiv/SimplexOptimizerMultiDirectionalTest.java
@@ -25,7 +25,7 @@
import org.apache.commons.math4.legacy.optim.nonlinear.scalar.GoalType;
import org.apache.commons.math4.legacy.optim.nonlinear.scalar.ObjectiveFunction;
import org.apache.commons.math4.legacy.core.MathArrays;
-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;
import org.junit.Ignore;
@@ -198,7 +198,7 @@
final double x = point[0];
final double y = point[1];
final double twoS2 = 2.0 * std * std;
- return 1.0 / (twoS2 * AccurateMath.PI) * AccurateMath.exp(-(x * x + y * y) / twoS2);
+ return 1.0 / (twoS2 * JdkMath.PI) * JdkMath.exp(-(x * x + y * y) / twoS2);
}
}
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/univariate/BrentOptimizerTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/univariate/BrentOptimizerTest.java
index fa09cab..e716354 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/univariate/BrentOptimizerTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/univariate/BrentOptimizerTest.java
@@ -29,7 +29,7 @@
import org.apache.commons.math4.legacy.optim.MaxEval;
import org.apache.commons.math4.legacy.optim.nonlinear.scalar.GoalType;
import org.apache.commons.math4.legacy.stat.descriptive.DescriptiveStatistics;
-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;
@@ -212,7 +212,7 @@
final UnivariateFunction f = new UnivariateFunction() {
@Override
public double value(double x) {
- final double sqrtX = AccurateMath.sqrt(x);
+ final double sqrtX = JdkMath.sqrt(x);
final double a = 1e2 * sqrtX;
final double b = 1e6 / x;
final double c = 1e4 / sqrtX;
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/univariate/MultiStartUnivariateOptimizerTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/univariate/MultiStartUnivariateOptimizerTest.java
index 59b09db..27f2992 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/univariate/MultiStartUnivariateOptimizerTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/optim/univariate/MultiStartUnivariateOptimizerTest.java
@@ -24,7 +24,7 @@
import org.apache.commons.math4.legacy.optim.nonlinear.scalar.GoalType;
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;
@@ -60,8 +60,8 @@
new SearchInterval(-100.0, 100.0));
UnivariatePointValuePair[] optima = optimizer.getOptima();
for (int i = 1; i < optima.length; ++i) {
- double d = (optima[i].getPoint() - optima[i-1].getPoint()) / (2 * AccurateMath.PI);
- Assert.assertTrue(AccurateMath.abs(d - AccurateMath.rint(d)) < 1.0e-8);
+ double d = (optima[i].getPoint() - optima[i-1].getPoint()) / (2 * JdkMath.PI);
+ Assert.assertTrue(JdkMath.abs(d - JdkMath.rint(d)) < 1.0e-8);
Assert.assertEquals(-1.0, f.value(optima[i].getPoint()), 1.0e-10);
Assert.assertEquals(f.value(optima[i].getPoint()), optima[i].getValue(), 1.0e-10);
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/random/CorrelatedVectorFactoryTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/random/CorrelatedVectorFactoryTest.java
index 64829a7..f6f59fc 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/random/CorrelatedVectorFactoryTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/random/CorrelatedVectorFactoryTest.java
@@ -30,7 +30,7 @@
import org.apache.commons.math4.legacy.stat.correlation.StorelessCovariance;
import org.apache.commons.math4.legacy.stat.descriptive.moment.VectorialCovariance;
import org.apache.commons.math4.legacy.stat.descriptive.moment.VectorialMean;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
public class CorrelatedVectorFactoryTest {
private double[] mean;
@@ -84,8 +84,8 @@
for (int i = 0; i < 10; i++) {
double[] generated = sg.get();
for (int j = 0; j < generated.length; ++j) {
- min[j] = AccurateMath.min(min[j], generated[j]);
- max[j] = AccurateMath.max(max[j], generated[j]);
+ min[j] = JdkMath.min(min[j], generated[j]);
+ max[j] = JdkMath.max(max[j], generated[j]);
}
}
for (int j = 0; j < min.length; ++j) {
@@ -110,7 +110,7 @@
for (int j = 0; j <= i; ++j) {
Assert.assertEquals(covariance.getEntry(i, j),
estimatedCovariance.getEntry(i, j),
- 1e-1 * (1 + AccurateMath.abs(mean[i])) * (1 + AccurateMath.abs(mean[j])));
+ 1e-1 * (1 + JdkMath.abs(mean[i])) * (1 + JdkMath.abs(mean[j])));
}
}
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/StatUtilsTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/StatUtilsTest.java
index aad318d..d0d3c42 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/StatUtilsTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/StatUtilsTest.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.DescriptiveStatistics;
-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;
@@ -206,13 +206,13 @@
// test one
x = new double[] {TWO};
- TestUtils.assertEquals(AccurateMath.log(TWO), StatUtils.sumLog(x), TOLERANCE);
- TestUtils.assertEquals(AccurateMath.log(TWO), StatUtils.sumLog(x, 0, 1), TOLERANCE);
+ TestUtils.assertEquals(JdkMath.log(TWO), StatUtils.sumLog(x), TOLERANCE);
+ TestUtils.assertEquals(JdkMath.log(TWO), StatUtils.sumLog(x, 0, 1), TOLERANCE);
// test many
x = new double[] {ONE, TWO, TWO, THREE};
- TestUtils.assertEquals(AccurateMath.log(ONE) + 2.0 * AccurateMath.log(TWO) + AccurateMath.log(THREE), StatUtils.sumLog(x), TOLERANCE);
- TestUtils.assertEquals(2.0 * AccurateMath.log(TWO), StatUtils.sumLog(x, 1, 2), TOLERANCE);
+ TestUtils.assertEquals(JdkMath.log(ONE) + 2.0 * JdkMath.log(TWO) + JdkMath.log(THREE), StatUtils.sumLog(x), TOLERANCE);
+ TestUtils.assertEquals(2.0 * JdkMath.log(TWO), StatUtils.sumLog(x, 1, 2), TOLERANCE);
}
@Test
@@ -453,9 +453,9 @@
// expected
}
test = new double[] {2, 4, 6, 8};
- Assert.assertEquals(AccurateMath.exp(0.25d * StatUtils.sumLog(test)),
+ Assert.assertEquals(JdkMath.exp(0.25d * StatUtils.sumLog(test)),
StatUtils.geometricMean(test), Double.MIN_VALUE);
- Assert.assertEquals(AccurateMath.exp(0.5 * StatUtils.sumLog(test, 0, 2)),
+ Assert.assertEquals(JdkMath.exp(0.5 * StatUtils.sumLog(test, 0, 2)),
StatUtils.geometricMean(test, 0, 2), Double.MIN_VALUE);
}
@@ -467,7 +467,7 @@
@Test
public void testNormalize1() {
double sample[] = { 50, 100 };
- double expectedSample[] = { -25 / AccurateMath.sqrt(1250), 25 / AccurateMath.sqrt(1250) };
+ double expectedSample[] = { -25 / JdkMath.sqrt(1250), 25 / JdkMath.sqrt(1250) };
double[] out = StatUtils.normalize(sample);
for (int i = 0; i < out.length; i++) {
Assert.assertTrue(Precision.equals(out[i], expectedSample[i], 1));
@@ -486,7 +486,7 @@
int length = 77;
double sample[] = new double[length];
for (int i = 0; i < length; i++) {
- sample[i] = AccurateMath.random();
+ sample[i] = JdkMath.random();
}
// normalize this sample
double standardizedSample[] = StatUtils.normalize(sample);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/correlation/PearsonsCorrelationTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/correlation/PearsonsCorrelationTest.java
index 1b503fe..87f5631 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/correlation/PearsonsCorrelationTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/correlation/PearsonsCorrelationTest.java
@@ -21,7 +21,7 @@
import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
import org.apache.commons.math4.legacy.linear.BlockRealMatrix;
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.junit.Assert;
import org.junit.Test;
@@ -236,7 +236,7 @@
RealMatrix stdErrors = corrInstance.getCorrelationStandardErrors();
for (int i = 0; i < 5; i++) {
for (int j = 0; j < i; j++) {
- double t = AccurateMath.abs(rValues.getEntry(i, j)) / stdErrors.getEntry(i, j);
+ double t = JdkMath.abs(rValues.getEntry(i, j)) / stdErrors.getEntry(i, j);
double p = 2 * (1 - tDistribution.cumulativeProbability(t));
Assert.assertEquals(p, pValues.getEntry(i, j), 10E-15);
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/MultivariateSummaryStatisticsTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/MultivariateSummaryStatisticsTest.java
index 3cb7cd9..0c2a86b 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/MultivariateSummaryStatisticsTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/MultivariateSummaryStatisticsTest.java
@@ -23,7 +23,7 @@
import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
import org.apache.commons.math4.legacy.exception.MathIllegalStateException;
import org.apache.commons.math4.legacy.stat.descriptive.moment.Mean;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
import org.junit.Test;
import org.junit.Assert;
@@ -211,8 +211,8 @@
Assert.assertEquals( 2.9129506302439405217, u.getGeometricMean()[1], 1.0e-10);
Assert.assertEquals( 2, u.getMean()[0], 1.0e-10);
Assert.assertEquals( 3, u.getMean()[1], 1.0e-10);
- Assert.assertEquals(AccurateMath.sqrt(2.0 / 3.0), u.getStandardDeviation()[0], 1.0e-10);
- Assert.assertEquals(AccurateMath.sqrt(2.0 / 3.0), u.getStandardDeviation()[1], 1.0e-10);
+ Assert.assertEquals(JdkMath.sqrt(2.0 / 3.0), u.getStandardDeviation()[0], 1.0e-10);
+ Assert.assertEquals(JdkMath.sqrt(2.0 / 3.0), u.getStandardDeviation()[1], 1.0e-10);
Assert.assertEquals(2.0 / 3.0, u.getCovariance().getEntry(0, 0), 1.0e-10);
Assert.assertEquals(2.0 / 3.0, u.getCovariance().getEntry(0, 1), 1.0e-10);
Assert.assertEquals(2.0 / 3.0, u.getCovariance().getEntry(1, 0), 1.0e-10);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/StorelessUnivariateStatisticAbstractTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/StorelessUnivariateStatisticAbstractTest.java
index 5ee9afe..4c87cbe 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/StorelessUnivariateStatisticAbstractTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/StorelessUnivariateStatisticAbstractTest.java
@@ -18,7 +18,7 @@
import org.apache.commons.math4.legacy.TestUtils;
import org.apache.commons.math4.legacy.stat.descriptive.moment.SecondMoment;
-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;
@@ -191,7 +191,7 @@
StorelessUnivariateStatistic replica = null;
// Randomly select a portion of testArray to load first
- long index = AccurateMath.round((AccurateMath.random()) * testArray.length);
+ long index = JdkMath.round((JdkMath.random()) * testArray.length);
// Put first half in master and copy master to replica
master.incrementAll(testArray, 0, (int) index);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/SummaryStatisticsTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/SummaryStatisticsTest.java
index 62feb77..77a60fc 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/SummaryStatisticsTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/SummaryStatisticsTest.java
@@ -23,7 +23,7 @@
import org.apache.commons.math4.legacy.stat.descriptive.moment.Mean;
import org.apache.commons.math4.legacy.stat.descriptive.moment.Variance;
import org.apache.commons.math4.legacy.stat.descriptive.summary.Sum;
-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;
/**
@@ -40,7 +40,7 @@
private final double sum = 8;
private final double var = 0.666666666666666666667;
private final double popVar = 0.5;
- private final double std = AccurateMath.sqrt(var);
+ private final double std = JdkMath.sqrt(var);
private final double n = 4;
private final double min = 1;
private final double max = 3;
@@ -271,7 +271,7 @@
u.addValue(3);
Assert.assertEquals(4, u.getMean(), 1E-14);
Assert.assertEquals(4, u.getSumOfLogs(), 1E-14);
- Assert.assertEquals(AccurateMath.exp(2), u.getGeometricMean(), 1E-14);
+ Assert.assertEquals(JdkMath.exp(2), u.getGeometricMean(), 1E-14);
u.clear();
u.addValue(1);
u.addValue(2);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/UnivariateStatisticAbstractTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/UnivariateStatisticAbstractTest.java
index 78fb1e6..4e10397 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/UnivariateStatisticAbstractTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/UnivariateStatisticAbstractTest.java
@@ -24,7 +24,7 @@
import org.apache.commons.statistics.distribution.NormalDistribution;
import org.apache.commons.statistics.distribution.ContinuousDistribution;
import org.apache.commons.statistics.distribution.UniformDiscreteDistribution;
-import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.core.jdkmath.JdkMath;
import org.apache.commons.rng.simple.RandomSource;
import org.junit.Assert;
import org.junit.Test;
@@ -38,7 +38,7 @@
protected double geoMean = 12.070589161633011d;
protected double var = 10.00235930735931d;
- protected double std = AccurateMath.sqrt(var);
+ protected double std = JdkMath.sqrt(var);
protected double skew = 1.437423729196190d;
protected double kurt = 2.377191264804700d;
@@ -59,7 +59,7 @@
protected double weightedMean = 12.366995073891626d;
protected double weightedVar = 9.974760968886391d;
- protected double weightedStd = AccurateMath.sqrt(weightedVar);
+ protected double weightedStd = JdkMath.sqrt(weightedVar);
protected double weightedProduct = 8517647448765288000000d;
protected double weightedSum = 251.05d;
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/moment/StandardDeviationTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/moment/StandardDeviationTest.java
index d2dd77c..3b9d8ea 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/moment/StandardDeviationTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/moment/StandardDeviationTest.java
@@ -18,7 +18,7 @@
import org.apache.commons.math4.legacy.stat.descriptive.StorelessUnivariateStatisticAbstractTest;
import org.apache.commons.math4.legacy.stat.descriptive.UnivariateStatistic;
-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;
@@ -89,7 +89,7 @@
for (int i = 0; i < v.length; i++) {
sum += (v[i] - mean) * (v[i] - mean);
}
- return AccurateMath.sqrt(sum / v.length);
+ return JdkMath.sqrt(sum / v.length);
}
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/rank/PSquarePercentileTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/rank/PSquarePercentileTest.java
index a1c0ab9..970c235 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/rank/PSquarePercentileTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/descriptive/rank/PSquarePercentileTest.java
@@ -36,7 +36,7 @@
import org.apache.commons.math4.legacy.stat.descriptive.StorelessUnivariateStatisticAbstractTest;
import org.apache.commons.math4.legacy.stat.descriptive.UnivariateStatistic;
import org.apache.commons.math4.legacy.stat.descriptive.rank.PSquarePercentile.PSquareMarkers;
-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;
@@ -74,7 +74,7 @@
StorelessUnivariateStatistic replica = null;
// select a portion of testArray till 75 % of the length to load first
- long index = AccurateMath.round(0.75 * testArray.length);
+ long index = JdkMath.round(0.75 * testArray.length);
// Put first half in master and copy master to replica
master.incrementAll(testArray, 0, (int) index);
@@ -108,7 +108,7 @@
// select a portion of testArray which is 10% of the length to load
// first
- long index = AccurateMath.round(0.1 * testArray.length);
+ long index = JdkMath.round(0.1 * testArray.length);
// Put first half in master and copy master to replica
master.incrementAll(testArray, 0, (int) index);
@@ -543,8 +543,8 @@
if (Double.isNaN(a)) {
Assert.assertTrue("" + b + " is not NaN.", Double.isNaN(a));
} else {
- double max = AccurateMath.max(a, b);
- double percentage = AccurateMath.abs(a - b) / max;
+ double max = JdkMath.max(a, b);
+ double percentage = JdkMath.abs(a - b) / max;
double deviation = delta;
Assert.assertTrue(String.format(
"Deviated = %f and is beyond %f as a=%f, b=%f",
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/GTestTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/GTestTest.java
index 3f544eb..95295d1 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/GTestTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/GTestTest.java
@@ -21,7 +21,7 @@
import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
import org.apache.commons.math4.legacy.exception.OutOfRangeException;
import org.apache.commons.math4.legacy.exception.ZeroException;
-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;
@@ -275,17 +275,17 @@
// negative because k11 is lower than expected
Assert.assertTrue(testStatistic.rootLogLikelihoodRatio(36, 21928, 60280, 623876) < 0.0);
- Assert.assertEquals(AccurateMath.sqrt(2.772589), testStatistic.rootLogLikelihoodRatio(1, 0, 0, 1), 0.000001);
- Assert.assertEquals(-AccurateMath.sqrt(2.772589), testStatistic.rootLogLikelihoodRatio(0, 1, 1, 0), 0.000001);
- Assert.assertEquals(AccurateMath.sqrt(27.72589), testStatistic.rootLogLikelihoodRatio(10, 0, 0, 10), 0.00001);
+ Assert.assertEquals(JdkMath.sqrt(2.772589), testStatistic.rootLogLikelihoodRatio(1, 0, 0, 1), 0.000001);
+ Assert.assertEquals(-JdkMath.sqrt(2.772589), testStatistic.rootLogLikelihoodRatio(0, 1, 1, 0), 0.000001);
+ Assert.assertEquals(JdkMath.sqrt(27.72589), testStatistic.rootLogLikelihoodRatio(10, 0, 0, 10), 0.00001);
- Assert.assertEquals(AccurateMath.sqrt(39.33052), testStatistic.rootLogLikelihoodRatio(5, 1995, 0, 100000), 0.00001);
- Assert.assertEquals(-AccurateMath.sqrt(39.33052), testStatistic.rootLogLikelihoodRatio(0, 100000, 5, 1995), 0.00001);
+ Assert.assertEquals(JdkMath.sqrt(39.33052), testStatistic.rootLogLikelihoodRatio(5, 1995, 0, 100000), 0.00001);
+ Assert.assertEquals(-JdkMath.sqrt(39.33052), testStatistic.rootLogLikelihoodRatio(0, 100000, 5, 1995), 0.00001);
- Assert.assertEquals(AccurateMath.sqrt(4730.737), testStatistic.rootLogLikelihoodRatio(1000, 1995, 1000, 100000), 0.001);
- Assert.assertEquals(-AccurateMath.sqrt(4730.737), testStatistic.rootLogLikelihoodRatio(1000, 100000, 1000, 1995), 0.001);
+ Assert.assertEquals(JdkMath.sqrt(4730.737), testStatistic.rootLogLikelihoodRatio(1000, 1995, 1000, 100000), 0.001);
+ Assert.assertEquals(-JdkMath.sqrt(4730.737), testStatistic.rootLogLikelihoodRatio(1000, 100000, 1000, 1995), 0.001);
- Assert.assertEquals(AccurateMath.sqrt(5734.343), testStatistic.rootLogLikelihoodRatio(1000, 1000, 1000, 100000), 0.001);
- Assert.assertEquals(AccurateMath.sqrt(5714.932), testStatistic.rootLogLikelihoodRatio(1000, 1000, 1000, 99000), 0.001);
+ Assert.assertEquals(JdkMath.sqrt(5734.343), testStatistic.rootLogLikelihoodRatio(1000, 1000, 1000, 100000), 0.001);
+ Assert.assertEquals(JdkMath.sqrt(5714.932), testStatistic.rootLogLikelihoodRatio(1000, 1000, 1000, 99000), 0.001);
}
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/InferenceTestUtilsTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/InferenceTestUtilsTest.java
index 1d14a31..47280dc 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/InferenceTestUtilsTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/InferenceTestUtilsTest.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.stat.descriptive.SummaryStatistics;
-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;
@@ -511,18 +511,18 @@
// negative because k11 is lower than expected
Assert.assertTrue(InferenceTestUtils.rootLogLikelihoodRatio(36, 21928, 60280, 623876) < 0.0);
- Assert.assertEquals(AccurateMath.sqrt(2.772589), InferenceTestUtils.rootLogLikelihoodRatio(1, 0, 0, 1), 0.000001);
- Assert.assertEquals(-AccurateMath.sqrt(2.772589), InferenceTestUtils.rootLogLikelihoodRatio(0, 1, 1, 0), 0.000001);
- Assert.assertEquals(AccurateMath.sqrt(27.72589), InferenceTestUtils.rootLogLikelihoodRatio(10, 0, 0, 10), 0.00001);
+ Assert.assertEquals(JdkMath.sqrt(2.772589), InferenceTestUtils.rootLogLikelihoodRatio(1, 0, 0, 1), 0.000001);
+ Assert.assertEquals(-JdkMath.sqrt(2.772589), InferenceTestUtils.rootLogLikelihoodRatio(0, 1, 1, 0), 0.000001);
+ Assert.assertEquals(JdkMath.sqrt(27.72589), InferenceTestUtils.rootLogLikelihoodRatio(10, 0, 0, 10), 0.00001);
- Assert.assertEquals(AccurateMath.sqrt(39.33052), InferenceTestUtils.rootLogLikelihoodRatio(5, 1995, 0, 100000), 0.00001);
- Assert.assertEquals(-AccurateMath.sqrt(39.33052), InferenceTestUtils.rootLogLikelihoodRatio(0, 100000, 5, 1995), 0.00001);
+ Assert.assertEquals(JdkMath.sqrt(39.33052), InferenceTestUtils.rootLogLikelihoodRatio(5, 1995, 0, 100000), 0.00001);
+ Assert.assertEquals(-JdkMath.sqrt(39.33052), InferenceTestUtils.rootLogLikelihoodRatio(0, 100000, 5, 1995), 0.00001);
- Assert.assertEquals(AccurateMath.sqrt(4730.737), InferenceTestUtils.rootLogLikelihoodRatio(1000, 1995, 1000, 100000), 0.001);
- Assert.assertEquals(-AccurateMath.sqrt(4730.737), InferenceTestUtils.rootLogLikelihoodRatio(1000, 100000, 1000, 1995), 0.001);
+ Assert.assertEquals(JdkMath.sqrt(4730.737), InferenceTestUtils.rootLogLikelihoodRatio(1000, 1995, 1000, 100000), 0.001);
+ Assert.assertEquals(-JdkMath.sqrt(4730.737), InferenceTestUtils.rootLogLikelihoodRatio(1000, 100000, 1000, 1995), 0.001);
- Assert.assertEquals(AccurateMath.sqrt(5734.343), InferenceTestUtils.rootLogLikelihoodRatio(1000, 1000, 1000, 100000), 0.001);
- Assert.assertEquals(AccurateMath.sqrt(5714.932), InferenceTestUtils.rootLogLikelihoodRatio(1000, 1000, 1000, 99000), 0.001);
+ Assert.assertEquals(JdkMath.sqrt(5734.343), InferenceTestUtils.rootLogLikelihoodRatio(1000, 1000, 1000, 100000), 0.001);
+ Assert.assertEquals(JdkMath.sqrt(5714.932), InferenceTestUtils.rootLogLikelihoodRatio(1000, 1000, 1000, 99000), 0.001);
}
@Test
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/KolmogorovSmirnovTestTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/KolmogorovSmirnovTestTest.java
index a03b4ff..df66769 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/KolmogorovSmirnovTestTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/inference/KolmogorovSmirnovTestTest.java
@@ -26,7 +26,7 @@
import org.apache.commons.rng.simple.RandomSource;
import org.apache.commons.rng.UniformRandomProvider;
import org.apache.commons.numbers.combinatorics.BinomialCoefficient;
-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.exception.NotANumberException;
import org.apache.commons.math4.legacy.exception.InsufficientDataException;
@@ -261,7 +261,7 @@
n = k[i];
m = k[j];
for (int l = 0; l < alpha.length; l++) {
- final double dCrit = c[l] * AccurateMath.sqrt((n + m) / (n * m));
+ final double dCrit = c[l] * JdkMath.sqrt((n + m) / (n * m));
checkApproximateTable(k[i], k[j], dCrit, alpha[l], tol);
}
}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/regression/MillerUpdatingRegressionTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/regression/MillerUpdatingRegressionTest.java
index f40a7f6..114f598 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/regression/MillerUpdatingRegressionTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/regression/MillerUpdatingRegressionTest.java
@@ -20,7 +20,7 @@
import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
import org.apache.commons.math4.legacy.linear.RealMatrix;
import org.apache.commons.math4.legacy.stat.correlation.PearsonsCorrelation;
-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,10 +68,10 @@
double[] y = new double[airdata[0].length];
for (int i = 0; i < airdata[0].length; i++) {
xAll[i] = new double[3];
- xAll[i][0] = AccurateMath.log(airdata[3][i]);
- xAll[i][1] = AccurateMath.log(airdata[4][i]);
+ xAll[i][0] = JdkMath.log(airdata[3][i]);
+ xAll[i][1] = JdkMath.log(airdata[4][i]);
xAll[i][2] = airdata[5][i];
- y[i] = AccurateMath.log(airdata[2][i]);
+ y[i] = JdkMath.log(airdata[2][i]);
}
instance.addObservations(xAll, y);
if (instance.getN() != xAll.length) {
@@ -170,10 +170,10 @@
for (int i = 0; i < airdata[0].length; i++) {
x[i] = new double[4];
x[i][0] = 1.0;
- x[i][1] = AccurateMath.log(airdata[3][i]);
- x[i][2] = AccurateMath.log(airdata[4][i]);
+ x[i][1] = JdkMath.log(airdata[3][i]);
+ x[i][2] = JdkMath.log(airdata[4][i]);
x[i][3] = airdata[5][i];
- y[i] = AccurateMath.log(airdata[2][i]);
+ y[i] = JdkMath.log(airdata[2][i]);
}
instance.addObservations(x, y);
@@ -202,10 +202,10 @@
double[] y = new double[airdata[0].length];
for (int i = 0; i < airdata[0].length; i++) {
x[i] = new double[3];
- x[i][0] = AccurateMath.log(airdata[3][i]);
- x[i][1] = AccurateMath.log(airdata[4][i]);
+ x[i][0] = JdkMath.log(airdata[3][i]);
+ x[i][1] = JdkMath.log(airdata[4][i]);
x[i][2] = airdata[5][i];
- y[i] = AccurateMath.log(airdata[2][i]);
+ y[i] = JdkMath.log(airdata[2][i]);
}
instance.addObservations(x, y);
@@ -723,10 +723,10 @@
// for (int i = 0; i < airdata[0].length; i++) {
// x[i] = new double[4];
// x[i][0] = 1.0;
-// x[i][1] = AccurateMath.log(airdata[3][i]);
-// x[i][2] = AccurateMath.log(airdata[4][i]);
+// x[i][1] = JdkMath.log(airdata[3][i]);
+// x[i][2] = JdkMath.log(airdata[4][i]);
// x[i][3] = airdata[5][i];
-// y[i] = AccurateMath.log(airdata[2][i]);
+// y[i] = JdkMath.log(airdata[2][i]);
// }
//
// instance.addObservations(x, y);
@@ -740,16 +740,16 @@
//
// double[] beta = result.getParameterEstimates();
// double[] betar = resultInverse.getParameterEstimates();
-// if (AccurateMath.abs(beta[0] - betar[0]) > 1.0e-14) {
+// if (JdkMath.abs(beta[0] - betar[0]) > 1.0e-14) {
// Assert.fail("Parameters not correct after reorder (0,3)");
// }
-// if (AccurateMath.abs(beta[1] - betar[1]) > 1.0e-14) {
+// if (JdkMath.abs(beta[1] - betar[1]) > 1.0e-14) {
// Assert.fail("Parameters not correct after reorder (1,2)");
// }
-// if (AccurateMath.abs(beta[2] - betar[2]) > 1.0e-14) {
+// if (JdkMath.abs(beta[2] - betar[2]) > 1.0e-14) {
// Assert.fail("Parameters not correct after reorder (2,1)");
// }
-// if (AccurateMath.abs(beta[3] - betar[3]) > 1.0e-14) {
+// if (JdkMath.abs(beta[3] - betar[3]) > 1.0e-14) {
// Assert.fail("Parameters not correct after reorder (3,0)");
// }
// }
@@ -765,8 +765,8 @@
x[i] = new double[4];
x2[i] = new double[5];
x[i][0] = 1.0;
- x[i][1] = AccurateMath.log(airdata[3][i]);
- x[i][2] = AccurateMath.log(airdata[4][i]);
+ x[i][1] = JdkMath.log(airdata[3][i]);
+ x[i][2] = JdkMath.log(airdata[4][i]);
x[i][3] = airdata[5][i];
x2[i][0] = x[i][0];
@@ -775,7 +775,7 @@
x2[i][3] = x[i][3];
x2[i][4] = x[i][3];
- y[i] = AccurateMath.log(airdata[2][i]);
+ y[i] = JdkMath.log(airdata[2][i]);
}
instance.addObservations(x, y);
@@ -791,14 +791,14 @@
double[] ser = resultRedundant.getStdErrorOfEstimates();
for (int i = 0; i < beta.length; i++) {
- if (AccurateMath.abs(beta[i] - betar[i]) > 1.0e-8) {
+ if (JdkMath.abs(beta[i] - betar[i]) > 1.0e-8) {
Assert.fail("Parameters not correctly estimated");
}
- if (AccurateMath.abs(se[i] - ser[i]) > 1.0e-8) {
+ if (JdkMath.abs(se[i] - ser[i]) > 1.0e-8) {
Assert.fail("Standard errors not correctly estimated");
}
for (int j = 0; j < i; j++) {
- if (AccurateMath.abs(result.getCovarianceOfParameters(i, j)
+ if (JdkMath.abs(result.getCovarianceOfParameters(i, j)
- resultRedundant.getCovarianceOfParameters(i, j)) > 1.0e-8) {
Assert.fail("Variance Covariance not correct");
}
@@ -825,8 +825,8 @@
x[i] = new double[4];
x2[i] = new double[7];
x[i][0] = 1.0;
- x[i][1] = AccurateMath.log(airdata[3][i]);
- x[i][2] = AccurateMath.log(airdata[4][i]);
+ x[i][1] = JdkMath.log(airdata[3][i]);
+ x[i][2] = JdkMath.log(airdata[4][i]);
x[i][3] = airdata[5][i];
x2[i][0] = x[i][0];
@@ -837,7 +837,7 @@
x2[i][5] = x[i][3];
x2[i][6] = x[i][2];
- y[i] = AccurateMath.log(airdata[2][i]);
+ y[i] = JdkMath.log(airdata[2][i]);
}
instance.addObservations(x, y);
@@ -852,71 +852,71 @@
double[] se = result.getStdErrorOfEstimates();
double[] ser = resultRedundant.getStdErrorOfEstimates();
- if (AccurateMath.abs(beta[0] - betar[0]) > 1.0e-8) {
+ if (JdkMath.abs(beta[0] - betar[0]) > 1.0e-8) {
Assert.fail("Parameters not correct after reorder (0,3)");
}
- if (AccurateMath.abs(beta[1] - betar[2]) > 1.0e-8) {
+ if (JdkMath.abs(beta[1] - betar[2]) > 1.0e-8) {
Assert.fail("Parameters not correct after reorder (1,2)");
}
- if (AccurateMath.abs(beta[2] - betar[3]) > 1.0e-8) {
+ if (JdkMath.abs(beta[2] - betar[3]) > 1.0e-8) {
Assert.fail("Parameters not correct after reorder (2,1)");
}
- if (AccurateMath.abs(beta[3] - betar[5]) > 1.0e-8) {
+ if (JdkMath.abs(beta[3] - betar[5]) > 1.0e-8) {
Assert.fail("Parameters not correct after reorder (3,0)");
}
- if (AccurateMath.abs(se[0] - ser[0]) > 1.0e-8) {
+ if (JdkMath.abs(se[0] - ser[0]) > 1.0e-8) {
Assert.fail("Se not correct after reorder (0,3)");
}
- if (AccurateMath.abs(se[1] - ser[2]) > 1.0e-8) {
+ if (JdkMath.abs(se[1] - ser[2]) > 1.0e-8) {
Assert.fail("Se not correct after reorder (1,2)");
}
- if (AccurateMath.abs(se[2] - ser[3]) > 1.0e-8) {
+ if (JdkMath.abs(se[2] - ser[3]) > 1.0e-8) {
Assert.fail("Se not correct after reorder (2,1)");
}
- if (AccurateMath.abs(se[3] - ser[5]) > 1.0e-8) {
+ if (JdkMath.abs(se[3] - ser[5]) > 1.0e-8) {
Assert.fail("Se not correct after reorder (3,0)");
}
- if (AccurateMath.abs(result.getCovarianceOfParameters(0, 0)
+ if (JdkMath.abs(result.getCovarianceOfParameters(0, 0)
- resultRedundant.getCovarianceOfParameters(0, 0)) > 1.0e-8) {
Assert.fail("VCV not correct after reorder (0,0)");
}
- if (AccurateMath.abs(result.getCovarianceOfParameters(0, 1)
+ if (JdkMath.abs(result.getCovarianceOfParameters(0, 1)
- resultRedundant.getCovarianceOfParameters(0, 2)) > 1.0e-8) {
Assert.fail("VCV not correct after reorder (0,1)<->(0,2)");
}
- if (AccurateMath.abs(result.getCovarianceOfParameters(0, 2)
+ if (JdkMath.abs(result.getCovarianceOfParameters(0, 2)
- resultRedundant.getCovarianceOfParameters(0, 3)) > 1.0e-8) {
Assert.fail("VCV not correct after reorder (0,2)<->(0,1)");
}
- if (AccurateMath.abs(result.getCovarianceOfParameters(0, 3)
+ if (JdkMath.abs(result.getCovarianceOfParameters(0, 3)
- resultRedundant.getCovarianceOfParameters(0, 5)) > 1.0e-8) {
Assert.fail("VCV not correct after reorder (0,3)<->(0,3)");
}
- if (AccurateMath.abs(result.getCovarianceOfParameters(1, 0)
+ if (JdkMath.abs(result.getCovarianceOfParameters(1, 0)
- resultRedundant.getCovarianceOfParameters(2, 0)) > 1.0e-8) {
Assert.fail("VCV not correct after reorder (1,0)<->(2,0)");
}
- if (AccurateMath.abs(result.getCovarianceOfParameters(1, 1)
+ if (JdkMath.abs(result.getCovarianceOfParameters(1, 1)
- resultRedundant.getCovarianceOfParameters(2, 2)) > 1.0e-8) {
Assert.fail("VCV not correct (1,1)<->(2,1)");
}
- if (AccurateMath.abs(result.getCovarianceOfParameters(1, 2)
+ if (JdkMath.abs(result.getCovarianceOfParameters(1, 2)
- resultRedundant.getCovarianceOfParameters(2, 3)) > 1.0e-8) {
Assert.fail("VCV not correct (1,2)<->(2,2)");
}
- if (AccurateMath.abs(result.getCovarianceOfParameters(2, 0)
+ if (JdkMath.abs(result.getCovarianceOfParameters(2, 0)
- resultRedundant.getCovarianceOfParameters(3, 0)) > 1.0e-8) {
Assert.fail("VCV not correct (2,0)<->(1,0)");
}
- if (AccurateMath.abs(result.getCovarianceOfParameters(2, 1)
+ if (JdkMath.abs(result.getCovarianceOfParameters(2, 1)
- resultRedundant.getCovarianceOfParameters(3, 2)) > 1.0e-8) {
Assert.fail("VCV not correct (2,1)<->(1,2)");
}
- if (AccurateMath.abs(result.getCovarianceOfParameters(3, 3)
+ if (JdkMath.abs(result.getCovarianceOfParameters(3, 3)
- resultRedundant.getCovarianceOfParameters(5, 5)) > 1.0e-8) {
Assert.fail("VCV not correct (3,3)<->(3,2)");
}
@@ -941,10 +941,10 @@
for (int i = 0; i < airdata[0].length; i++) {
x[i] = new double[4];
x[i][0] = 1.0;
- x[i][1] = AccurateMath.log(airdata[3][i]);
- x[i][2] = AccurateMath.log(airdata[4][i]);
+ x[i][1] = JdkMath.log(airdata[3][i]);
+ x[i][2] = JdkMath.log(airdata[4][i]);
x[i][3] = airdata[5][i];
- y[i] = AccurateMath.log(airdata[2][i]);
+ y[i] = JdkMath.log(airdata[2][i]);
off = 0;
for (int j = 0; j < 4; j++) {
double tmp = x[i][j];
@@ -959,7 +959,7 @@
RealMatrix corr = pearson.getCorrelationMatrix();
off = 0;
for (int i = 0; i < 4; i++, off += i + 1) {
- diag[i] = AccurateMath.sqrt(cp[off]);
+ diag[i] = JdkMath.sqrt(cp[off]);
}
instance.addObservations(x, y);
@@ -969,14 +969,14 @@
int off2 = 6;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < i; j++) {
- if (AccurateMath.abs(pc[idx] - cp[off] / (diag[i] * diag[j])) > 1.0e-8) {
+ if (JdkMath.abs(pc[idx] - cp[off] / (diag[i] * diag[j])) > 1.0e-8) {
Assert.fail("Failed cross products... i = " + i + " j = " + j);
}
++idx;
++off;
}
++off;
- if (AccurateMath.abs(pc[i+off2] - yxcorr[ i] / (AccurateMath.sqrt(sumysq) * diag[i])) > 1.0e-8) {
+ if (JdkMath.abs(pc[i+off2] - yxcorr[ i] / (JdkMath.sqrt(sumysq) * diag[i])) > 1.0e-8) {
Assert.fail("Assert.failed cross product i = " + i + " y");
}
}
@@ -986,7 +986,7 @@
for (int i = 1; i < 4; i++) {
for (int j = 1; j < i; j++) {
- if (AccurateMath.abs(pc2[idx] - corr.getEntry(j, i)) > 1.0e-8) {
+ if (JdkMath.abs(pc2[idx] - corr.getEntry(j, i)) > 1.0e-8) {
Assert.fail("Failed cross products... i = " + i + " j = " + j);
}
++idx;
@@ -1007,10 +1007,10 @@
for (int i = 0; i < airdata[0].length; i++) {
x[i] = new double[4];
x[i][0] = 1.0;
- x[i][1] = AccurateMath.log(airdata[3][i]);
- x[i][2] = AccurateMath.log(airdata[4][i]);
+ x[i][1] = JdkMath.log(airdata[3][i]);
+ x[i][2] = JdkMath.log(airdata[4][i]);
x[i][3] = airdata[5][i];
- y[i] = AccurateMath.log(airdata[2][i]);
+ y[i] = JdkMath.log(airdata[2][i]);
}
instance.addObservations(x, y);
OLSMultipleLinearRegression ols = new OLSMultipleLinearRegression();
@@ -1030,10 +1030,10 @@
double[] y = new double[airdata[0].length];
for (int i = 0; i < airdata[0].length; i++) {
x[i] = new double[3];
- x[i][0] = AccurateMath.log(airdata[3][i]);
- x[i][1] = AccurateMath.log(airdata[4][i]);
+ x[i][0] = JdkMath.log(airdata[3][i]);
+ x[i][1] = JdkMath.log(airdata[4][i]);
x[i][2] = airdata[5][i];
- y[i] = AccurateMath.log(airdata[2][i]);
+ y[i] = JdkMath.log(airdata[2][i]);
}
instance.addObservations(x, y);
OLSMultipleLinearRegression ols = new OLSMultipleLinearRegression();
@@ -1066,15 +1066,15 @@
double[] y = new double[airdata[0].length];
for (int i = 0; i < airdata[0].length; i++) {
x[i] = new double[3];
- x[i][i0] = AccurateMath.log(airdata[3][i]);
- x[i][i1] = AccurateMath.log(airdata[4][i]);
+ x[i][i0] = JdkMath.log(airdata[3][i]);
+ x[i][i1] = JdkMath.log(airdata[4][i]);
x[i][iExclude] = airdata[5][i];
xReduced[i] = new double[2];
- xReduced[i][0] = AccurateMath.log(airdata[3][i]);
- xReduced[i][1] = AccurateMath.log(airdata[4][i]);
+ xReduced[i][0] = JdkMath.log(airdata[3][i]);
+ xReduced[i][1] = JdkMath.log(airdata[4][i]);
- y[i] = AccurateMath.log(airdata[2][i]);
+ y[i] = JdkMath.log(airdata[2][i]);
}
instance.addObservations(x, y);
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/regression/SimpleRegressionTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/regression/SimpleRegressionTest.java
index e2084d5..6ab2376 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/regression/SimpleRegressionTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/stat/regression/SimpleRegressionTest.java
@@ -22,7 +22,7 @@
import org.apache.commons.math4.legacy.exception.OutOfRangeException;
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;
@@ -163,46 +163,46 @@
if (model1.getN() != model2.getN()) {
return false;
}
- if (AccurateMath.abs(model1.getIntercept() - model2.getIntercept()) > tol) {
+ if (JdkMath.abs(model1.getIntercept() - model2.getIntercept()) > tol) {
return false;
}
- if (AccurateMath.abs(model1.getInterceptStdErr() - model2.getInterceptStdErr()) > tol) {
+ if (JdkMath.abs(model1.getInterceptStdErr() - model2.getInterceptStdErr()) > tol) {
return false;
}
- if (AccurateMath.abs(model1.getMeanSquareError() - model2.getMeanSquareError()) > tol) {
+ if (JdkMath.abs(model1.getMeanSquareError() - model2.getMeanSquareError()) > tol) {
return false;
}
- if (AccurateMath.abs(model1.getR() - model2.getR()) > tol) {
+ if (JdkMath.abs(model1.getR() - model2.getR()) > tol) {
return false;
}
- if (AccurateMath.abs(model1.getRegressionSumSquares() - model2.getRegressionSumSquares()) > tol) {
+ if (JdkMath.abs(model1.getRegressionSumSquares() - model2.getRegressionSumSquares()) > tol) {
return false;
}
- if (AccurateMath.abs(model1.getRSquare() - model2.getRSquare()) > tol) {
+ if (JdkMath.abs(model1.getRSquare() - model2.getRSquare()) > tol) {
return false;
}
- if (AccurateMath.abs(model1.getSignificance() - model2.getSignificance()) > tol) {
+ if (JdkMath.abs(model1.getSignificance() - model2.getSignificance()) > tol) {
return false;
}
- if (AccurateMath.abs(model1.getSlope() - model2.getSlope()) > tol) {
+ if (JdkMath.abs(model1.getSlope() - model2.getSlope()) > tol) {
return false;
}
- if (AccurateMath.abs(model1.getSlopeConfidenceInterval() - model2.getSlopeConfidenceInterval()) > tol) {
+ if (JdkMath.abs(model1.getSlopeConfidenceInterval() - model2.getSlopeConfidenceInterval()) > tol) {
return false;
}
- if (AccurateMath.abs(model1.getSlopeStdErr() - model2.getSlopeStdErr()) > tol) {
+ if (JdkMath.abs(model1.getSlopeStdErr() - model2.getSlopeStdErr()) > tol) {
return false;
}
- if (AccurateMath.abs(model1.getSumOfCrossProducts() - model2.getSumOfCrossProducts()) > tol) {
+ if (JdkMath.abs(model1.getSumOfCrossProducts() - model2.getSumOfCrossProducts()) > tol) {
return false;
}
- if (AccurateMath.abs(model1.getSumSquaredErrors() - model2.getSumSquaredErrors()) > tol) {
+ if (JdkMath.abs(model1.getSumSquaredErrors() - model2.getSumSquaredErrors()) > tol) {
return false;
}
- if (AccurateMath.abs(model1.getTotalSumSquares() - model2.getTotalSumSquares()) > tol) {
+ if (JdkMath.abs(model1.getTotalSumSquares() - model2.getTotalSumSquares()) > tol) {
return false;
}
- if (AccurateMath.abs(model1.getXSumSquares() - model2.getXSumSquares()) > tol) {
+ if (JdkMath.abs(model1.getXSumSquares() - model2.getXSumSquares()) > tol) {
return false;
}
return true;
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/util/ComplexFormatAbstractTest.java b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/util/ComplexFormatAbstractTest.java
index fa538e1..b729df9 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/util/ComplexFormatAbstractTest.java
+++ b/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/util/ComplexFormatAbstractTest.java
@@ -29,7 +29,7 @@
import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
import org.apache.commons.math4.legacy.exception.NoDataException;
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;
public abstract class ComplexFormatAbstractTest {
@@ -395,7 +395,7 @@
@Test
public void testFormatNumber() {
ComplexFormat cf = ComplexFormat.getInstance(getLocale());
- Double pi = Double.valueOf(AccurateMath.PI);
+ Double pi = Double.valueOf(JdkMath.PI);
String text = cf.format(pi);
Assert.assertEquals("3" + getDecimalCharacter() + "1415926536", text);
}
diff --git a/commons-math-legacy/src/test/maxima/special/RealFunctionValidation/RealFunctionValidation.java b/commons-math-legacy/src/test/maxima/special/RealFunctionValidation/RealFunctionValidation.java
index a8e9b82..f34642f 100755
--- a/commons-math-legacy/src/test/maxima/special/RealFunctionValidation/RealFunctionValidation.java
+++ b/commons-math-legacy/src/test/maxima/special/RealFunctionValidation/RealFunctionValidation.java
@@ -29,7 +29,7 @@
import java.util.Properties;
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;
/*
* plot 'logGamma.dat' binary format="%double%double" endian=big u 1:2 w l
@@ -298,11 +298,11 @@
types[i]);
}
final double expected = in.readDouble();
- if (AccurateMath.abs(expected) > 1E-16) {
+ if (JdkMath.abs(expected) > 1E-16) {
final Object value = method.invoke(null, parameters);
final double actual = ((Double) value).doubleValue();
- final double err = AccurateMath.abs(actual - expected);
- final double ulps = err / AccurateMath.ulp(expected);
+ final double err = JdkMath.abs(actual - expected);
+ final double ulps = err / JdkMath.ulp(expected);
out.writeDouble(expected);
out.writeDouble(actual);
out.writeDouble(ulps);
diff --git a/pom.xml b/pom.xml
index 602ca68..c618f11 100644
--- a/pom.xml
+++ b/pom.xml
@@ -113,6 +113,7 @@
<modules> <!-- Do not change the ordering of the 4 blocks below. -->
<!-- 1. Modules that do not depend on "legacy" codes. -->
+ <module>commons-math-core</module>
<module>commons-math-neuralnet</module>
<module>commons-math-transform</module>
@@ -151,6 +152,12 @@
<dependency>
<groupId>org.apache.commons</groupId>
+ <artifactId>commons-math4-core</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.apache.commons</groupId>
<artifactId>commons-math4-legacy-exception</artifactId>
<version>${project.version}</version>
</dependency>
diff --git a/src/main/resources/checkstyle/checkstyle-suppressions.xml b/src/main/resources/checkstyle/checkstyle-suppressions.xml
index f35fe25..1e58559 100644
--- a/src/main/resources/checkstyle/checkstyle-suppressions.xml
+++ b/src/main/resources/checkstyle/checkstyle-suppressions.xml
@@ -29,7 +29,7 @@
<suppress checks="LineLength" files=".*[/\\]Dfp\.java" />
<suppress checks="MethodLength" files=".*[/\\]Dfp.*\.java" />
<suppress checks="MethodLength" files=".*[/\\]AccurateMath\.java" />
- <suppress checks="MethodName" files=".*[/\\]AccurateMath\.java" />
+ <suppress checks="MethodName" files=".*[/\\]jdkmath[/\\].*Math\.java" />
<suppress checks="LocalFinalVariableName" files=".*[/\\]AccurateMath\.java" />
<suppress checks="ParameterNumber" files=".*[/\\]RealFieldElement\.java" />
<suppress checks="ParameterNumber" files=".*[/\\]Dfp\.java" />
