* The field is linked to the number of digits and acts as a factory * for {@link Dfp} instances. *
- * @return {@link org.apache.commons.math4.legacy.Field Field} (really a {@link DfpField}) to which the instance belongs + * @return {@link org.apache.commons.math4.legacy.core.Field Field} (really a {@link DfpField}) to which the instance belongs */ @Override public DfpField getField() { @@ -2579,7 +2578,7 @@ public class Dfp implements RealFieldElementAnother floating point class. This one is built using radix 10000 + * which is 104, so its almost decimal.
+ * + *The design goals here are: + *
Trade offs: + *
Numbers are represented in the following form: + *
+ * n = sign × mant × (radix)exp;
+ * IEEE 854-1987 Notes and differences
+ * + *IEEE 854 requires the radix to be either 2 or 10. The radix here is + * 10000, so that requirement is not met, but it is possible that a + * subclassed can be made to make it behave as a radix 10 + * number. It is my opinion that if it looks and behaves as a radix + * 10 number then it is one and that requirement would be met.
+ * + *The radix of 10000 was chosen because it should be faster to operate + * on 4 decimal digits at once instead of one at a time. Radix 10 behavior + * can be realized by add an additional rounding step to ensure that + * the number of decimal digits represented is constant.
+ * + *The IEEE standard specifically leaves out internal data encoding, + * so it is reasonable to conclude that such a subclass of this radix + * 10000 system is merely an encoding of a radix 10 system.
+ * + *IEEE 854 also specifies the existence of "sub-normal" numbers. This + * class does not contain any such entities. The most significant radix + * 10000 digit is always non-zero. Instead, we support "gradual underflow" + * by raising the underflow flag for numbers less with exponent less than + * expMin, but don't flush to zero until the exponent reaches MIN_EXP-digits. + * Thus the smallest number we can represent would be: + * 1E(-(MIN_EXP-digits-1)∗4), eg, for digits=5, MIN_EXP=-32767, that would + * be 1e-131092.
+ * + *IEEE 854 defines that the implied radix point lies just to the right + * of the most significant digit and to the left of the remaining digits. + * This implementation puts the implied radix point to the left of all + * digits including the most significant one. The most significant digit + * here is the one just to the right of the radix point. This is a fine + * detail and is really only a matter of definition. Any side effects of + * this can be rendered invisible by a subclass.
+ * + */ +package org.apache.commons.math4.legacy.core.dfp; diff --git a/commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMath.java b/commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMath.java new file mode 100644 index 000000000..a6307fb36 --- /dev/null +++ b/commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMath.java @@ -0,0 +1,4351 @@ +/* + * 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.legacy.core.jdkmath; + +import java.io.PrintStream; + +import org.apache.commons.numbers.core.Precision; +import org.apache.commons.math4.legacy.exception.MathArithmeticException; +import org.apache.commons.math4.legacy.exception.util.LocalizedFormats; + +/** + * Portable alternative to {@link Math} and {@link StrictMath}. + *+ * Caveat: At the time of implementation, the {@code AccurateMath} functions + * were often faster and/or more accurate than their JDK equivalent. + * Nowadays, it would not be surprising that they are always slower (due + * to the various JVM optimizations that have appeared since Java 5). + * However, any change to this class should ensure that the current + * accuracy is not lost. + *
+ * AccurateMath is a drop-in replacement for both Math and StrictMath. This + * means that for any method in Math (say {@code Math.sin(x)} or + * {@code Math.cbrt(y)}), user can directly change the class and use the + * methods as is (using {@code AccurateMath.sin(x)} or {@code AccurateMath.cbrt(y)} + * in the previous example). + *
+ *+ * AccurateMath speed is achieved by relying heavily on optimizing compilers + * to native code present in many JVMs today and use of large tables. + * The larger tables are lazily initialized on first use, so that the setup + * time does not penalize methods that don't need them. + *
+ *+ * Note that AccurateMath is + * extensively used inside Apache Commons Math, so by calling some algorithms, + * the overhead when the tables need to be initialized will occur + * regardless of the end-user calling AccurateMath methods directly or not. + * Performance figures for a specific JVM and hardware can be evaluated by + * running the AccurateMathTestPerformance tests in the test directory of the source + * distribution. + *
+ *+ * AccurateMath accuracy should be mostly independent of the JVM as it relies only + * on IEEE-754 basic operations and on embedded tables. Almost all operations + * are accurate to about 0.5 ulp throughout the domain range. This statement, + * of course is only a rough global observed behavior, it is not a + * guarantee for every double numbers input (see William Kahan's Table + * Maker's Dilemma). + *
+ *+ * AccurateMath additionally implements the following methods not found in Math/StrictMath: + *
+ * This compile-time constant should be set to true only if one explicitly + * wants to compute the tables at class loading time instead of using the + * already computed ones provided as literal arrays below. + *
+ */ + private static final boolean RECOMPUTE_TABLES_AT_RUNTIME = false; + + /** log(2) (high bits). */ + private static final double LN_2_A = 0.693147063255310059; + + /** log(2) (low bits). */ + private static final double LN_2_B = 1.17304635250823482e-7; + + /** Coefficients for log, when input 0.99 < x < 1.01. */ + private static final double LN_QUICK_COEF[][] = { + {1.0, 5.669184079525E-24}, + {-0.25, -0.25}, + {0.3333333134651184, 1.986821492305628E-8}, + {-0.25, -6.663542893624021E-14}, + {0.19999998807907104, 1.1921056801463227E-8}, + {-0.1666666567325592, -7.800414592973399E-9}, + {0.1428571343421936, 5.650007086920087E-9}, + {-0.12502530217170715, -7.44321345601866E-11}, + {0.11113807559013367, 9.219544613762692E-9}, + }; + + /** Coefficients for log in the range of 1.0 < x < 1.0 + 2^-10. */ + private static final double LN_HI_PREC_COEF[][] = { + {1.0, -6.032174644509064E-23}, + {-0.25, -0.25}, + {0.3333333134651184, 1.9868161777724352E-8}, + {-0.2499999701976776, -2.957007209750105E-8}, + {0.19999954104423523, 1.5830993332061267E-10}, + {-0.16624879837036133, -2.6033824355191673E-8} + }; + + /** Sine, Cosine, Tangent tables are for 0, 1/8, 2/8, ... 13/8 = PI/2 approx. */ + private static final int SINE_TABLE_LEN = 14; + + /** Sine table (high bits). */ + private static final double SINE_TABLE_A[] = + { + +0.0d, + +0.1246747374534607d, + +0.24740394949913025d, + +0.366272509098053d, + +0.4794255495071411d, + +0.5850973129272461d, + +0.6816387176513672d, + +0.7675435543060303d, + +0.8414709568023682d, + +0.902267575263977d, + +0.9489846229553223d, + +0.9808930158615112d, + +0.9974949359893799d, + +0.9985313415527344d, + }; + + /** Sine table (low bits). */ + private static final double SINE_TABLE_B[] = + { + +0.0d, + -4.068233003401932E-9d, + +9.755392680573412E-9d, + +1.9987994582857286E-8d, + -1.0902938113007961E-8d, + -3.9986783938944604E-8d, + +4.23719669792332E-8d, + -5.207000323380292E-8d, + +2.800552834259E-8d, + +1.883511811213715E-8d, + -3.5997360512765566E-9d, + +4.116164446561962E-8d, + +5.0614674548127384E-8d, + -1.0129027912496858E-9d, + }; + + /** Cosine table (high bits). */ + private static final double COSINE_TABLE_A[] = + { + +1.0d, + +0.9921976327896118d, + +0.9689123630523682d, + +0.9305076599121094d, + +0.8775825500488281d, + +0.8109631538391113d, + +0.7316888570785522d, + +0.6409968137741089d, + +0.5403022766113281d, + +0.4311765432357788d, + +0.3153223395347595d, + +0.19454771280288696d, + +0.07073719799518585d, + -0.05417713522911072d, + }; + + /** Cosine table (low bits). */ + private static final double COSINE_TABLE_B[] = + { + +0.0d, + +3.4439717236742845E-8d, + +5.865827662008209E-8d, + -3.7999795083850525E-8d, + +1.184154459111628E-8d, + -3.43338934259355E-8d, + +1.1795268640216787E-8d, + +4.438921624363781E-8d, + +2.925681159240093E-8d, + -2.6437112632041807E-8d, + +2.2860509143963117E-8d, + -4.813899778443457E-9d, + +3.6725170580355583E-9d, + +2.0217439756338078E-10d, + }; + + + /** Tangent table, used by atan() (high bits). */ + private static final double TANGENT_TABLE_A[] = + { + +0.0d, + +0.1256551444530487d, + +0.25534194707870483d, + +0.3936265707015991d, + +0.5463024377822876d, + +0.7214844226837158d, + +0.9315965175628662d, + +1.1974215507507324d, + +1.5574076175689697d, + +2.092571258544922d, + +3.0095696449279785d, + +5.041914939880371d, + +14.101419448852539d, + -18.430862426757812d, + }; + + /** Tangent table, used by atan() (low bits). */ + private static final double TANGENT_TABLE_B[] = + { + +0.0d, + -7.877917738262007E-9d, + -2.5857668567479893E-8d, + +5.2240336371356666E-9d, + +5.206150291559893E-8d, + +1.8307188599677033E-8d, + -5.7618793749770706E-8d, + +7.848361555046424E-8d, + +1.0708593250394448E-7d, + +1.7827257129423813E-8d, + +2.893485277253286E-8d, + +3.1660099222737955E-7d, + +4.983191803254889E-7d, + -3.356118100840571E-7d, + }; + + /** Bits of 1/(2*pi), need for reducePayneHanek(). */ + private static final long RECIP_2PI[] = new long[] { + (0x28be60dbL << 32) | 0x9391054aL, + (0x7f09d5f4L << 32) | 0x7d4d3770L, + (0x36d8a566L << 32) | 0x4f10e410L, + (0x7f9458eaL << 32) | 0xf7aef158L, + (0x6dc91b8eL << 32) | 0x909374b8L, + (0x01924bbaL << 32) | 0x82746487L, + (0x3f877ac7L << 32) | 0x2c4a69cfL, + (0xba208d7dL << 32) | 0x4baed121L, + (0x3a671c09L << 32) | 0xad17df90L, + (0x4e64758eL << 32) | 0x60d4ce7dL, + (0x272117e2L << 32) | 0xef7e4a0eL, + (0xc7fe25ffL << 32) | 0xf7816603L, + (0xfbcbc462L << 32) | 0xd6829b47L, + (0xdb4d9fb3L << 32) | 0xc9f2c26dL, + (0xd3d18fd9L << 32) | 0xa797fa8bL, + (0x5d49eeb1L << 32) | 0xfaf97c5eL, + (0xcf41ce7dL << 32) | 0xe294a4baL, + 0x9afed7ecL << 32 }; + + /** Bits of pi/4, need for reducePayneHanek(). */ + private static final long PI_O_4_BITS[] = new long[] { + (0xc90fdaa2L << 32) | 0x2168c234L, + (0xc4c6628bL << 32) | 0x80dc1cd1L }; + + /** Eighths. + * This is used by sinQ, because its faster to do a table lookup than + * a multiply in this time-critical routine + */ + private static final double EIGHTHS[] = {0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0, 1.125, 1.25, 1.375, 1.5, 1.625}; + + /** Table of 2^((n+2)/3) */ + private static final double CBRTTWO[] = { 0.6299605249474366, + 0.7937005259840998, + 1.0, + 1.2599210498948732, + 1.5874010519681994 }; + + /* + * There are 52 bits in the mantissa of a double. + * For additional precision, the code splits double numbers into two parts, + * by clearing the low order 30 bits if possible, and then performs the arithmetic + * on each half separately. + */ + + /** + * 0x40000000 - used to split a double into two parts, both with the low order bits cleared. + * Equivalent to 2^30. + */ + private static final long HEX_40000000 = 0x40000000L; // 1073741824L + + /** Mask used to clear low order 30 bits */ + private static final long MASK_30BITS = -1L - (HEX_40000000 -1); // 0xFFFFFFFFC0000000L; + + /** Mask used to clear the non-sign part of an int. */ + private static final int MASK_NON_SIGN_INT = 0x7fffffff; + + /** Mask used to clear the non-sign part of a long. */ + private static final long MASK_NON_SIGN_LONG = 0x7fffffffffffffffl; + + /** Mask used to extract exponent from double bits. */ + private static final long MASK_DOUBLE_EXPONENT = 0x7ff0000000000000L; + + /** Mask used to extract mantissa from double bits. */ + private static final long MASK_DOUBLE_MANTISSA = 0x000fffffffffffffL; + + /** Mask used to add implicit high order bit for normalized double. */ + private static final long IMPLICIT_HIGH_BIT = 0x0010000000000000L; + + /** 2^52 - double numbers this large must be integral (no fraction) or NaN or Infinite */ + private static final double TWO_POWER_52 = 4503599627370496.0; + + /** Constant: {@value}. */ + private static final double F_1_3 = 1d / 3d; + /** Constant: {@value}. */ + private static final double F_1_5 = 1d / 5d; + /** Constant: {@value}. */ + private static final double F_1_7 = 1d / 7d; + /** Constant: {@value}. */ + private static final double F_1_9 = 1d / 9d; + /** Constant: {@value}. */ + private static final double F_1_11 = 1d / 11d; + /** Constant: {@value}. */ + private static final double F_1_13 = 1d / 13d; + /** Constant: {@value}. */ + private static final double F_1_15 = 1d / 15d; + /** Constant: {@value}. */ + private static final double F_1_17 = 1d / 17d; + /** Constant: {@value}. */ + private static final double F_3_4 = 3d / 4d; + /** Constant: {@value}. */ + private static final double F_15_16 = 15d / 16d; + /** Constant: {@value}. */ + private static final double F_13_14 = 13d / 14d; + /** Constant: {@value}. */ + private static final double F_11_12 = 11d / 12d; + /** Constant: {@value}. */ + private static final double F_9_10 = 9d / 10d; + /** Constant: {@value}. */ + private static final double F_7_8 = 7d / 8d; + /** Constant: {@value}. */ + private static final double F_5_6 = 5d / 6d; + /** Constant: {@value}. */ + private static final double F_1_2 = 1d / 2d; + /** Constant: {@value}. */ + private static final double F_1_4 = 1d / 4d; + + /** + * Private Constructor + */ + private AccurateMath() {} + + // Generic helper methods + + /** + * Get the high order bits from the mantissa. + * Equivalent to adding and subtracting HEX_40000 but also works for very large numbers + * + * @param d the value to split + * @return the high order part of the mantissa + */ + private static double doubleHighPart(double d) { + if (d > -Precision.SAFE_MIN && d < Precision.SAFE_MIN){ + return d; // These are un-normalised - don't try to convert + } + long xl = Double.doubleToRawLongBits(d); // can take raw bits because just gonna convert it back + xl &= MASK_30BITS; // Drop low order bits + return Double.longBitsToDouble(xl); + } + + /** Compute the square root of a number. + *Note: this implementation currently delegates to {@link Math#sqrt} + * @param a number on which evaluation is done + * @return square root of a + */ + public static double sqrt(final double a) { + return Math.sqrt(a); + } + + /** Compute the hyperbolic cosine of a number. + * @param x number on which evaluation is done + * @return hyperbolic cosine of x + */ + public static double cosh(double x) { + if (Double.isNaN(x)) { + return x; + } + + // cosh[z] = (exp(z) + exp(-z))/2 + + // for numbers with magnitude 20 or so, + // exp(-z) can be ignored in comparison with exp(z) + + if (x > 20) { + if (x >= LOG_MAX_VALUE) { + // Avoid overflow (MATH-905). + final double t = exp(0.5 * x); + return (0.5 * t) * t; + } else { + return 0.5 * exp(x); + } + } else if (x < -20) { + if (x <= -LOG_MAX_VALUE) { + // Avoid overflow (MATH-905). + final double t = exp(-0.5 * x); + return (0.5 * t) * t; + } else { + return 0.5 * exp(-x); + } + } + + final double hiPrec[] = new double[2]; + if (x < 0.0) { + x = -x; + } + exp(x, 0.0, hiPrec); + + double ya = hiPrec[0] + hiPrec[1]; + double yb = -(ya - hiPrec[0] - hiPrec[1]); + + double temp = ya * HEX_40000000; + double yaa = ya + temp - temp; + double yab = ya - yaa; + + // recip = 1/y + double recip = 1.0/ya; + temp = recip * HEX_40000000; + double recipa = recip + temp - temp; + double recipb = recip - recipa; + + // Correct for rounding in division + recipb += (1.0 - yaa*recipa - yaa*recipb - yab*recipa - yab*recipb) * recip; + // Account for yb + recipb += -yb * recip * recip; + + // y = y + 1/y + temp = ya + recipa; + yb += -(temp - ya - recipa); + ya = temp; + temp = ya + recipb; + yb += -(temp - ya - recipb); + ya = temp; + + double result = ya + yb; + result *= 0.5; + return result; + } + + /** Compute the hyperbolic sine of a number. + * @param x number on which evaluation is done + * @return hyperbolic sine of x + */ + public static double sinh(double x) { + boolean negate = false; + if (Double.isNaN(x)) { + return x; + } + + // sinh[z] = (exp(z) - exp(-z) / 2 + + // for values of z larger than about 20, + // exp(-z) can be ignored in comparison with exp(z) + + if (x > 20) { + if (x >= LOG_MAX_VALUE) { + // Avoid overflow (MATH-905). + final double t = exp(0.5 * x); + return (0.5 * t) * t; + } else { + return 0.5 * exp(x); + } + } else if (x < -20) { + if (x <= -LOG_MAX_VALUE) { + // Avoid overflow (MATH-905). + final double t = exp(-0.5 * x); + return (-0.5 * t) * t; + } else { + return -0.5 * exp(-x); + } + } + + if (x == 0) { + return x; + } + + if (x < 0.0) { + x = -x; + negate = true; + } + + double result; + + if (x > 0.25) { + double hiPrec[] = new double[2]; + exp(x, 0.0, hiPrec); + + double ya = hiPrec[0] + hiPrec[1]; + double yb = -(ya - hiPrec[0] - hiPrec[1]); + + double temp = ya * HEX_40000000; + double yaa = ya + temp - temp; + double yab = ya - yaa; + + // recip = 1/y + double recip = 1.0/ya; + temp = recip * HEX_40000000; + double recipa = recip + temp - temp; + double recipb = recip - recipa; + + // Correct for rounding in division + recipb += (1.0 - yaa*recipa - yaa*recipb - yab*recipa - yab*recipb) * recip; + // Account for yb + recipb += -yb * recip * recip; + + recipa = -recipa; + recipb = -recipb; + + // y = y + 1/y + temp = ya + recipa; + yb += -(temp - ya - recipa); + ya = temp; + temp = ya + recipb; + yb += -(temp - ya - recipb); + ya = temp; + + result = ya + yb; + result *= 0.5; + } + else { + double hiPrec[] = new double[2]; + expm1(x, hiPrec); + + double ya = hiPrec[0] + hiPrec[1]; + double yb = -(ya - hiPrec[0] - hiPrec[1]); + + /* Compute expm1(-x) = -expm1(x) / (expm1(x) + 1) */ + double denom = 1.0 + ya; + double denomr = 1.0 / denom; + double denomb = -(denom - 1.0 - ya) + yb; + double ratio = ya * denomr; + double temp = ratio * HEX_40000000; + double ra = ratio + temp - temp; + double rb = ratio - ra; + + temp = denom * HEX_40000000; + double za = denom + temp - temp; + double zb = denom - za; + + rb += (ya - za*ra - za*rb - zb*ra - zb*rb) * denomr; + + // Adjust for yb + rb += yb*denomr; // numerator + rb += -ya * denomb * denomr * denomr; // denominator + + // y = y - 1/y + temp = ya + ra; + yb += -(temp - ya - ra); + ya = temp; + temp = ya + rb; + yb += -(temp - ya - rb); + ya = temp; + + result = ya + yb; + result *= 0.5; + } + + if (negate) { + result = -result; + } + + return result; + } + + /** Compute the hyperbolic tangent of a number. + * @param x number on which evaluation is done + * @return hyperbolic tangent of x + */ + public static double tanh(double x) { + boolean negate = false; + + if (Double.isNaN(x)) { + return x; + } + + // tanh[z] = sinh[z] / cosh[z] + // = (exp(z) - exp(-z)) / (exp(z) + exp(-z)) + // = (exp(2x) - 1) / (exp(2x) + 1) + + // for magnitude > 20, sinh[z] == cosh[z] in double precision + + if (x > 20.0) { + return 1.0; + } + + if (x < -20) { + return -1.0; + } + + if (x == 0) { + return x; + } + + if (x < 0.0) { + x = -x; + negate = true; + } + + double result; + if (x >= 0.5) { + double hiPrec[] = new double[2]; + // tanh(x) = (exp(2x) - 1) / (exp(2x) + 1) + exp(x*2.0, 0.0, hiPrec); + + double ya = hiPrec[0] + hiPrec[1]; + double yb = -(ya - hiPrec[0] - hiPrec[1]); + + /* Numerator */ + double na = -1.0 + ya; + double nb = -(na + 1.0 - ya); + double temp = na + yb; + nb += -(temp - na - yb); + na = temp; + + /* Denominator */ + double da = 1.0 + ya; + double db = -(da - 1.0 - ya); + temp = da + yb; + db += -(temp - da - yb); + da = temp; + + temp = da * HEX_40000000; + double daa = da + temp - temp; + double dab = da - daa; + + // ratio = na/da + double ratio = na/da; + temp = ratio * HEX_40000000; + double ratioa = ratio + temp - temp; + double ratiob = ratio - ratioa; + + // Correct for rounding in division + ratiob += (na - daa*ratioa - daa*ratiob - dab*ratioa - dab*ratiob) / da; + + // Account for nb + ratiob += nb / da; + // Account for db + ratiob += -db * na / da / da; + + result = ratioa + ratiob; + } + else { + double hiPrec[] = new double[2]; + // tanh(x) = expm1(2x) / (expm1(2x) + 2) + expm1(x*2.0, hiPrec); + + double ya = hiPrec[0] + hiPrec[1]; + double yb = -(ya - hiPrec[0] - hiPrec[1]); + + /* Numerator */ + double na = ya; + double nb = yb; + + /* Denominator */ + double da = 2.0 + ya; + double db = -(da - 2.0 - ya); + double temp = da + yb; + db += -(temp - da - yb); + da = temp; + + temp = da * HEX_40000000; + double daa = da + temp - temp; + double dab = da - daa; + + // ratio = na/da + double ratio = na/da; + temp = ratio * HEX_40000000; + double ratioa = ratio + temp - temp; + double ratiob = ratio - ratioa; + + // Correct for rounding in division + ratiob += (na - daa*ratioa - daa*ratiob - dab*ratioa - dab*ratiob) / da; + + // Account for nb + ratiob += nb / da; + // Account for db + ratiob += -db * na / da / da; + + result = ratioa + ratiob; + } + + if (negate) { + result = -result; + } + + return result; + } + + /** Compute the inverse hyperbolic cosine of a number. + * @param a number on which evaluation is done + * @return inverse hyperbolic cosine of a + */ + public static double acosh(final double a) { + return AccurateMath.log(a + AccurateMath.sqrt(a * a - 1)); + } + + /** Compute the inverse hyperbolic sine of a number. + * @param a number on which evaluation is done + * @return inverse hyperbolic sine of a + */ + public static double asinh(double a) { + boolean negative = false; + if (a < 0) { + negative = true; + a = -a; + } + + double absAsinh; + if (a > 0.167) { + absAsinh = AccurateMath.log(AccurateMath.sqrt(a * a + 1) + a); + } else { + final double a2 = a * a; + if (a > 0.097) { + absAsinh = a * (1 - a2 * (F_1_3 - a2 * (F_1_5 - a2 * (F_1_7 - a2 * (F_1_9 - a2 * (F_1_11 - a2 * (F_1_13 - a2 * (F_1_15 - a2 * F_1_17 * F_15_16) * F_13_14) * F_11_12) * F_9_10) * F_7_8) * F_5_6) * F_3_4) * F_1_2); + } else if (a > 0.036) { + absAsinh = a * (1 - a2 * (F_1_3 - a2 * (F_1_5 - a2 * (F_1_7 - a2 * (F_1_9 - a2 * (F_1_11 - a2 * F_1_13 * F_11_12) * F_9_10) * F_7_8) * F_5_6) * F_3_4) * F_1_2); + } else if (a > 0.0036) { + absAsinh = a * (1 - a2 * (F_1_3 - a2 * (F_1_5 - a2 * (F_1_7 - a2 * F_1_9 * F_7_8) * F_5_6) * F_3_4) * F_1_2); + } else { + absAsinh = a * (1 - a2 * (F_1_3 - a2 * F_1_5 * F_3_4) * F_1_2); + } + } + + return negative ? -absAsinh : absAsinh; + } + + /** Compute the inverse hyperbolic tangent of a number. + * @param a number on which evaluation is done + * @return inverse hyperbolic tangent of a + */ + public static double atanh(double a) { + boolean negative = false; + if (a < 0) { + negative = true; + a = -a; + } + + double absAtanh; + if (a > 0.15) { + absAtanh = 0.5 * AccurateMath.log((1 + a) / (1 - a)); + } else { + final double a2 = a * a; + if (a > 0.087) { + absAtanh = a * (1 + a2 * (F_1_3 + a2 * (F_1_5 + a2 * (F_1_7 + a2 * (F_1_9 + a2 * (F_1_11 + a2 * (F_1_13 + a2 * (F_1_15 + a2 * F_1_17)))))))); + } else if (a > 0.031) { + absAtanh = a * (1 + a2 * (F_1_3 + a2 * (F_1_5 + a2 * (F_1_7 + a2 * (F_1_9 + a2 * (F_1_11 + a2 * F_1_13)))))); + } else if (a > 0.003) { + absAtanh = a * (1 + a2 * (F_1_3 + a2 * (F_1_5 + a2 * (F_1_7 + a2 * F_1_9)))); + } else { + absAtanh = a * (1 + a2 * (F_1_3 + a2 * F_1_5)); + } + } + + return negative ? -absAtanh : absAtanh; + } + + /** Compute the signum of a number. + * The signum is -1 for negative numbers, +1 for positive numbers and 0 otherwise + * @param a number on which evaluation is done + * @return -1.0, -0.0, +0.0, +1.0 or NaN depending on sign of a + */ + public static double signum(final double a) { + return (a < 0.0) ? -1.0 : ((a > 0.0) ? 1.0 : a); // return +0.0/-0.0/NaN depending on a + } + + /** Compute the signum of a number. + * The signum is -1 for negative numbers, +1 for positive numbers and 0 otherwise + * @param a number on which evaluation is done + * @return -1.0, -0.0, +0.0, +1.0 or NaN depending on sign of a + */ + public static float signum(final float a) { + return (a < 0.0f) ? -1.0f : ((a > 0.0f) ? 1.0f : a); // return +0.0/-0.0/NaN depending on a + } + + /** Compute next number towards positive infinity. + * @param a number to which neighbor should be computed + * @return neighbor of a towards positive infinity + */ + public static double nextUp(final double a) { + return nextAfter(a, Double.POSITIVE_INFINITY); + } + + /** Compute next number towards positive infinity. + * @param a number to which neighbor should be computed + * @return neighbor of a towards positive infinity + */ + public static float nextUp(final float a) { + return nextAfter(a, Float.POSITIVE_INFINITY); + } + + /** Compute next number towards negative infinity. + * @param a number to which neighbor should be computed + * @return neighbor of a towards negative infinity + * @since 3.4 + */ + public static double nextDown(final double a) { + return nextAfter(a, Double.NEGATIVE_INFINITY); + } + + /** Compute next number towards negative infinity. + * @param a number to which neighbor should be computed + * @return neighbor of a towards negative infinity + * @since 3.4 + */ + public static float nextDown(final float a) { + return nextAfter(a, Float.NEGATIVE_INFINITY); + } + + /** Returns a pseudo-random number between 0.0 and 1.0. + *
Note: this implementation currently delegates to {@link Math#random}
+ * @return a random number between 0.0 and 1.0
+ */
+ public static double random() {
+ return Math.random();
+ }
+
+ /**
+ * Exponential function.
+ *
+ * Computes exp(x), function result is nearly rounded. It will be correctly
+ * rounded to the theoretical value for 99.9% of input values, otherwise it will
+ * have a 1 ULP error.
+ *
+ * Method:
+ * Lookup intVal = exp(int(x))
+ * Lookup fracVal = exp(int(x-int(x) / 1024.0) * 1024.0 );
+ * Compute z as the exponential of the remaining bits by a polynomial minus one
+ * exp(x) = intVal * fracVal * (1 + z)
+ *
+ * Accuracy:
+ * Calculation is done with 63 bits of precision, so result should be correctly
+ * rounded for 99.9% of input values, with less than 1 ULP error otherwise.
+ *
+ * @param x a double
+ * @return double ex
+ */
+ public static double exp(double x) {
+ return exp(x, 0.0, null);
+ }
+
+ /**
+ * Internal helper method for exponential function.
+ * @param x original argument of the exponential function
+ * @param extra extra bits of precision on input (To Be Confirmed)
+ * @param hiPrec extra bits of precision on output (To Be Confirmed)
+ * @return exp(x)
+ */
+ private static double exp(double x, double extra, double[] hiPrec) {
+ double intPartA;
+ double intPartB;
+ int intVal = (int) x;
+
+ /* Lookup exp(floor(x)).
+ * intPartA will have the upper 22 bits, intPartB will have the lower
+ * 52 bits.
+ */
+ if (x < 0.0) {
+
+ // We don't check against intVal here as conversion of large negative double values
+ // may be affected by a JIT bug. Subsequent comparisons can safely use intVal
+ if (x < -746d) {
+ if (hiPrec != null) {
+ hiPrec[0] = 0.0;
+ hiPrec[1] = 0.0;
+ }
+ return 0.0;
+ }
+
+ if (intVal < -709) {
+ /* This will produce a subnormal output */
+ final double result = exp(x+40.19140625, extra, hiPrec) / 285040095144011776.0;
+ if (hiPrec != null) {
+ hiPrec[0] /= 285040095144011776.0;
+ hiPrec[1] /= 285040095144011776.0;
+ }
+ return result;
+ }
+
+ if (intVal == -709) {
+ /* exp(1.494140625) is nearly a machine number... */
+ final double result = exp(x+1.494140625, extra, hiPrec) / 4.455505956692756620;
+ if (hiPrec != null) {
+ hiPrec[0] /= 4.455505956692756620;
+ hiPrec[1] /= 4.455505956692756620;
+ }
+ return result;
+ }
+
+ intVal--;
+
+ } else {
+ if (intVal > 709) {
+ if (hiPrec != null) {
+ hiPrec[0] = Double.POSITIVE_INFINITY;
+ hiPrec[1] = 0.0;
+ }
+ return Double.POSITIVE_INFINITY;
+ }
+
+ }
+
+ intPartA = ExpIntTable.EXP_INT_TABLE_A[EXP_INT_TABLE_MAX_INDEX+intVal];
+ intPartB = ExpIntTable.EXP_INT_TABLE_B[EXP_INT_TABLE_MAX_INDEX+intVal];
+
+ /* Get the fractional part of x, find the greatest multiple of 2^-10 less than
+ * x and look up the exp function of it.
+ * fracPartA will have the upper 22 bits, fracPartB the lower 52 bits.
+ */
+ final int intFrac = (int) ((x - intVal) * 1024.0);
+ final double fracPartA = ExpFracTable.EXP_FRAC_TABLE_A[intFrac];
+ final double fracPartB = ExpFracTable.EXP_FRAC_TABLE_B[intFrac];
+
+ /* epsilon is the difference in x from the nearest multiple of 2^-10. It
+ * has a value in the range 0 <= epsilon < 2^-10.
+ * Do the subtraction from x as the last step to avoid possible loss of precision.
+ */
+ final double epsilon = x - (intVal + intFrac / 1024.0);
+
+ /* Compute z = exp(epsilon) - 1.0 via a minimax polynomial. z has
+ full double precision (52 bits). Since z < 2^-10, we will have
+ 62 bits of precision when combined with the constant 1. This will be
+ used in the last addition below to get proper rounding. */
+
+ /* Remez generated polynomial. Converges on the interval [0, 2^-10], error
+ is less than 0.5 ULP */
+ double z = 0.04168701738764507;
+ z = z * epsilon + 0.1666666505023083;
+ z = z * epsilon + 0.5000000000042687;
+ z = z * epsilon + 1.0;
+ z = z * epsilon + -3.940510424527919E-20;
+
+ /* Compute (intPartA+intPartB) * (fracPartA+fracPartB) by binomial
+ expansion.
+ tempA is exact since intPartA and intPartB only have 22 bits each.
+ tempB will have 52 bits of precision.
+ */
+ double tempA = intPartA * fracPartA;
+ double tempB = intPartA * fracPartB + intPartB * fracPartA + intPartB * fracPartB;
+
+ /* Compute the result. (1+z)(tempA+tempB). Order of operations is
+ important. For accuracy add by increasing size. tempA is exact and
+ much larger than the others. If there are extra bits specified from the
+ pow() function, use them. */
+ final double tempC = tempB + tempA;
+
+ // If tempC is positive infinite, the evaluation below could result in NaN,
+ // because z could be negative at the same time.
+ if (tempC == Double.POSITIVE_INFINITY) {
+ return Double.POSITIVE_INFINITY;
+ }
+
+ final double result;
+ if (extra != 0.0) {
+ result = tempC*extra*z + tempC*extra + tempC*z + tempB + tempA;
+ } else {
+ result = tempC*z + tempB + tempA;
+ }
+
+ if (hiPrec != null) {
+ // If requesting high precision
+ hiPrec[0] = tempA;
+ hiPrec[1] = tempC*extra*z + tempC*extra + tempC*z + tempB;
+ }
+
+ return result;
+ }
+
+ /** Compute exp(x) - 1
+ * @param x number to compute shifted exponential
+ * @return exp(x) - 1
+ */
+ public static double expm1(double x) {
+ return expm1(x, null);
+ }
+
+ /** Internal helper method for expm1
+ * @param x number to compute shifted exponential
+ * @param hiPrecOut receive high precision result for -1.0 < x < 1.0
+ * @return exp(x) - 1
+ */
+ private static double expm1(double x, double hiPrecOut[]) {
+ if (Double.isNaN(x) || x == 0.0) { // NaN or zero
+ return x;
+ }
+
+ if (x <= -1.0 || x >= 1.0) {
+ // If not between +/- 1.0
+ //return exp(x) - 1.0;
+ double hiPrec[] = new double[2];
+ exp(x, 0.0, hiPrec);
+ if (x > 0.0) {
+ return -1.0 + hiPrec[0] + hiPrec[1];
+ } else {
+ final double ra = -1.0 + hiPrec[0];
+ double rb = -(ra + 1.0 - hiPrec[0]);
+ rb += hiPrec[1];
+ return ra + rb;
+ }
+ }
+
+ double baseA;
+ double baseB;
+ double epsilon;
+ boolean negative = false;
+
+ if (x < 0.0) {
+ x = -x;
+ negative = true;
+ }
+
+ {
+ int intFrac = (int) (x * 1024.0);
+ double tempA = ExpFracTable.EXP_FRAC_TABLE_A[intFrac] - 1.0;
+ double tempB = ExpFracTable.EXP_FRAC_TABLE_B[intFrac];
+
+ double temp = tempA + tempB;
+ tempB = -(temp - tempA - tempB);
+ tempA = temp;
+
+ temp = tempA * HEX_40000000;
+ baseA = tempA + temp - temp;
+ baseB = tempB + (tempA - baseA);
+
+ epsilon = x - intFrac/1024.0;
+ }
+
+
+ /* Compute expm1(epsilon) */
+ double zb = 0.008336750013465571;
+ zb = zb * epsilon + 0.041666663879186654;
+ zb = zb * epsilon + 0.16666666666745392;
+ zb = zb * epsilon + 0.49999999999999994;
+ zb *= epsilon;
+ zb *= epsilon;
+
+ double za = epsilon;
+ double temp = za + zb;
+ zb = -(temp - za - zb);
+ za = temp;
+
+ temp = za * HEX_40000000;
+ temp = za + temp - temp;
+ zb += za - temp;
+ za = temp;
+
+ /* Combine the parts. expm1(a+b) = expm1(a) + expm1(b) + expm1(a)*expm1(b) */
+ double ya = za * baseA;
+ //double yb = za*baseB + zb*baseA + zb*baseB;
+ temp = ya + za * baseB;
+ double yb = -(temp - ya - za * baseB);
+ ya = temp;
+
+ temp = ya + zb * baseA;
+ yb += -(temp - ya - zb * baseA);
+ ya = temp;
+
+ temp = ya + zb * baseB;
+ yb += -(temp - ya - zb*baseB);
+ ya = temp;
+
+ //ya = ya + za + baseA;
+ //yb = yb + zb + baseB;
+ temp = ya + baseA;
+ yb += -(temp - baseA - ya);
+ ya = temp;
+
+ temp = ya + za;
+ //yb += (ya > za) ? -(temp - ya - za) : -(temp - za - ya);
+ yb += -(temp - ya - za);
+ ya = temp;
+
+ temp = ya + baseB;
+ //yb += (ya > baseB) ? -(temp - ya - baseB) : -(temp - baseB - ya);
+ yb += -(temp - ya - baseB);
+ ya = temp;
+
+ temp = ya + zb;
+ //yb += (ya > zb) ? -(temp - ya - zb) : -(temp - zb - ya);
+ yb += -(temp - ya - zb);
+ ya = temp;
+
+ if (negative) {
+ /* Compute expm1(-x) = -expm1(x) / (expm1(x) + 1) */
+ double denom = 1.0 + ya;
+ double denomr = 1.0 / denom;
+ double denomb = -(denom - 1.0 - ya) + yb;
+ double ratio = ya * denomr;
+ temp = ratio * HEX_40000000;
+ final double ra = ratio + temp - temp;
+ double rb = ratio - ra;
+
+ temp = denom * HEX_40000000;
+ za = denom + temp - temp;
+ zb = denom - za;
+
+ rb += (ya - za * ra - za * rb - zb * ra - zb * rb) * denomr;
+
+ // f(x) = x/1+x
+ // Compute f'(x)
+ // Product rule: d(uv) = du*v + u*dv
+ // Chain rule: d(f(g(x)) = f'(g(x))*f(g'(x))
+ // d(1/x) = -1/(x*x)
+ // d(1/1+x) = -1/( (1+x)^2) * 1 = -1/((1+x)*(1+x))
+ // d(x/1+x) = -x/((1+x)(1+x)) + 1/1+x = 1 / ((1+x)(1+x))
+
+ // Adjust for yb
+ rb += yb * denomr; // numerator
+ rb += -ya * denomb * denomr * denomr; // denominator
+
+ // negate
+ ya = -ra;
+ yb = -rb;
+ }
+
+ if (hiPrecOut != null) {
+ hiPrecOut[0] = ya;
+ hiPrecOut[1] = yb;
+ }
+
+ return ya + yb;
+ }
+
+ /**
+ * Natural logarithm.
+ *
+ * @param x a double
+ * @return log(x)
+ */
+ public static double log(final double x) {
+ return log(x, null);
+ }
+
+ /**
+ * Internal helper method for natural logarithm function.
+ * @param x original argument of the natural logarithm function
+ * @param hiPrec extra bits of precision on output (To Be Confirmed)
+ * @return log(x)
+ */
+ private static double log(final double x, final double[] hiPrec) {
+ if (x==0) { // Handle special case of +0/-0
+ return Double.NEGATIVE_INFINITY;
+ }
+ long bits = Double.doubleToRawLongBits(x);
+
+ /* Handle special cases of negative input, and NaN */
+ if (((bits & 0x8000000000000000L) != 0 || Double.isNaN(x)) && x != 0.0) {
+ if (hiPrec != null) {
+ hiPrec[0] = Double.NaN;
+ }
+
+ return Double.NaN;
+ }
+
+ /* Handle special cases of Positive infinity. */
+ if (x == Double.POSITIVE_INFINITY) {
+ if (hiPrec != null) {
+ hiPrec[0] = Double.POSITIVE_INFINITY;
+ }
+
+ return Double.POSITIVE_INFINITY;
+ }
+
+ /* Extract the exponent */
+ int exp = (int)(bits >> 52)-1023;
+
+ if ((bits & 0x7ff0000000000000L) == 0) {
+ // Subnormal!
+ if (x == 0) {
+ // Zero
+ if (hiPrec != null) {
+ hiPrec[0] = Double.NEGATIVE_INFINITY;
+ }
+
+ return Double.NEGATIVE_INFINITY;
+ }
+
+ /* Normalize the subnormal number. */
+ bits <<= 1;
+ while ( (bits & 0x0010000000000000L) == 0) {
+ --exp;
+ bits <<= 1;
+ }
+ }
+
+
+ if ((exp == -1 || exp == 0) && x < 1.01 && x > 0.99 && hiPrec == null) {
+ /* The normal method doesn't work well in the range [0.99, 1.01], so call do a straight
+ polynomial expansion in higer precision. */
+
+ /* Compute x - 1.0 and split it */
+ double xa = x - 1.0;
+ double xb = xa - x + 1.0;
+ double tmp = xa * HEX_40000000;
+ double aa = xa + tmp - tmp;
+ double ab = xa - aa;
+ xa = aa;
+ xb = ab;
+
+ final double[] lnCoef_last = LN_QUICK_COEF[LN_QUICK_COEF.length - 1];
+ double ya = lnCoef_last[0];
+ double yb = lnCoef_last[1];
+
+ for (int i = LN_QUICK_COEF.length - 2; i >= 0; i--) {
+ /* Multiply a = y * x */
+ aa = ya * xa;
+ ab = ya * xb + yb * xa + yb * xb;
+ /* split, so now y = a */
+ tmp = aa * HEX_40000000;
+ ya = aa + tmp - tmp;
+ yb = aa - ya + ab;
+
+ /* Add a = y + lnQuickCoef */
+ final double[] lnCoef_i = LN_QUICK_COEF[i];
+ aa = ya + lnCoef_i[0];
+ ab = yb + lnCoef_i[1];
+ /* Split y = a */
+ tmp = aa * HEX_40000000;
+ ya = aa + tmp - tmp;
+ yb = aa - ya + ab;
+ }
+
+ /* Multiply a = y * x */
+ aa = ya * xa;
+ ab = ya * xb + yb * xa + yb * xb;
+ /* split, so now y = a */
+ tmp = aa * HEX_40000000;
+ ya = aa + tmp - tmp;
+ yb = aa - ya + ab;
+
+ return ya + yb;
+ }
+
+ // lnm is a log of a number in the range of 1.0 - 2.0, so 0 <= lnm < ln(2)
+ final double[] lnm = lnMant.LN_MANT[(int)((bits & 0x000ffc0000000000L) >> 42)];
+
+ /*
+ double epsilon = x / Double.longBitsToDouble(bits & 0xfffffc0000000000L);
+
+ epsilon -= 1.0;
+ */
+
+ // y is the most significant 10 bits of the mantissa
+ //double y = Double.longBitsToDouble(bits & 0xfffffc0000000000L);
+ //double epsilon = (x - y) / y;
+ final double epsilon = (bits & 0x3ffffffffffL) / (TWO_POWER_52 + (bits & 0x000ffc0000000000L));
+
+ double lnza = 0.0;
+ double lnzb = 0.0;
+
+ if (hiPrec != null) {
+ /* split epsilon -> x */
+ double tmp = epsilon * HEX_40000000;
+ double aa = epsilon + tmp - tmp;
+ double ab = epsilon - aa;
+ double xa = aa;
+ double xb = ab;
+
+ /* Need a more accurate epsilon, so adjust the division. */
+ final double numer = bits & 0x3ffffffffffL;
+ final double denom = TWO_POWER_52 + (bits & 0x000ffc0000000000L);
+ aa = numer - xa*denom - xb * denom;
+ xb += aa / denom;
+
+ /* Remez polynomial evaluation */
+ final double[] lnCoef_last = LN_HI_PREC_COEF[LN_HI_PREC_COEF.length-1];
+ double ya = lnCoef_last[0];
+ double yb = lnCoef_last[1];
+
+ for (int i = LN_HI_PREC_COEF.length - 2; i >= 0; i--) {
+ /* Multiply a = y * x */
+ aa = ya * xa;
+ ab = ya * xb + yb * xa + yb * xb;
+ /* split, so now y = a */
+ tmp = aa * HEX_40000000;
+ ya = aa + tmp - tmp;
+ yb = aa - ya + ab;
+
+ /* Add a = y + lnHiPrecCoef */
+ final double[] lnCoef_i = LN_HI_PREC_COEF[i];
+ aa = ya + lnCoef_i[0];
+ ab = yb + lnCoef_i[1];
+ /* Split y = a */
+ tmp = aa * HEX_40000000;
+ ya = aa + tmp - tmp;
+ yb = aa - ya + ab;
+ }
+
+ /* Multiply a = y * x */
+ aa = ya * xa;
+ ab = ya * xb + yb * xa + yb * xb;
+
+ /* split, so now lnz = a */
+ /*
+ tmp = aa * 1073741824.0;
+ lnza = aa + tmp - tmp;
+ lnzb = aa - lnza + ab;
+ */
+ lnza = aa + ab;
+ lnzb = -(lnza - aa - ab);
+ } else {
+ /* High precision not required. Eval Remez polynomial
+ using standard double precision */
+ lnza = -0.16624882440418567;
+ lnza = lnza * epsilon + 0.19999954120254515;
+ lnza = lnza * epsilon + -0.2499999997677497;
+ lnza = lnza * epsilon + 0.3333333333332802;
+ lnza = lnza * epsilon + -0.5;
+ lnza = lnza * epsilon + 1.0;
+ lnza *= epsilon;
+ }
+
+ /* Relative sizes:
+ * lnzb [0, 2.33E-10]
+ * lnm[1] [0, 1.17E-7]
+ * ln2B*exp [0, 1.12E-4]
+ * lnza [0, 9.7E-4]
+ * lnm[0] [0, 0.692]
+ * ln2A*exp [0, 709]
+ */
+
+ /* Compute the following sum:
+ * lnzb + lnm[1] + ln2B*exp + lnza + lnm[0] + ln2A*exp;
+ */
+
+ //return lnzb + lnm[1] + ln2B*exp + lnza + lnm[0] + ln2A*exp;
+ double a = LN_2_A*exp;
+ double b = 0.0;
+ double c = a+lnm[0];
+ double d = -(c-a-lnm[0]);
+ a = c;
+ b += d;
+
+ c = a + lnza;
+ d = -(c - a - lnza);
+ a = c;
+ b += d;
+
+ c = a + LN_2_B*exp;
+ d = -(c - a - LN_2_B*exp);
+ a = c;
+ b += d;
+
+ c = a + lnm[1];
+ d = -(c - a - lnm[1]);
+ a = c;
+ b += d;
+
+ c = a + lnzb;
+ d = -(c - a - lnzb);
+ a = c;
+ b += d;
+
+ if (hiPrec != null) {
+ hiPrec[0] = a;
+ hiPrec[1] = b;
+ }
+
+ return a + b;
+ }
+
+ /**
+ * Computes log(1 + x).
+ *
+ * @param x Number.
+ * @return {@code log(1 + x)}.
+ */
+ public static double log1p(final double x) {
+ if (x == -1) {
+ return Double.NEGATIVE_INFINITY;
+ }
+
+ if (x == Double.POSITIVE_INFINITY) {
+ return Double.POSITIVE_INFINITY;
+ }
+
+ if (x > 1e-6 ||
+ x < -1e-6) {
+ final double xpa = 1 + x;
+ final double xpb = -(xpa - 1 - x);
+
+ final double[] hiPrec = new double[2];
+ final double lores = log(xpa, hiPrec);
+ if (Double.isInfinite(lores)) { // Don't allow this to be converted to NaN
+ return lores;
+ }
+
+ // Do a taylor series expansion around xpa:
+ // f(x+y) = f(x) + f'(x) y + f''(x)/2 y^2
+ final double fx1 = xpb / xpa;
+ final double epsilon = 0.5 * fx1 + 1;
+ return epsilon * fx1 + hiPrec[1] + hiPrec[0];
+ } else {
+ // Value is small |x| < 1e6, do a Taylor series centered on 1.
+ final double y = (x * F_1_3 - F_1_2) * x + 1;
+ return y * x;
+ }
+ }
+
+ /** Compute the base 10 logarithm.
+ * @param x a number
+ * @return log10(x)
+ */
+ public static double log10(final double x) {
+ final double hiPrec[] = new double[2];
+
+ final double lores = log(x, hiPrec);
+ if (Double.isInfinite(lores)){ // don't allow this to be converted to NaN
+ return lores;
+ }
+
+ final double tmp = hiPrec[0] * HEX_40000000;
+ final double lna = hiPrec[0] + tmp - tmp;
+ final double lnb = hiPrec[0] - lna + hiPrec[1];
+
+ final double rln10a = 0.4342944622039795;
+ final double rln10b = 1.9699272335463627E-8;
+
+ return rln10b * lnb + rln10b * lna + rln10a * lnb + rln10a * lna;
+ }
+
+ /**
+ * Computes the
+ * logarithm in a given base.
+ *
+ * Returns {@code NaN} if either argument is negative.
+ * If {@code base} is 0 and {@code x} is positive, 0 is returned.
+ * If {@code base} is positive and {@code x} is 0,
+ * {@code Double.NEGATIVE_INFINITY} is returned.
+ * If both arguments are 0, the result is {@code NaN}.
+ *
+ * @param base Base of the logarithm, must be greater than 0.
+ * @param x Argument, must be greater than 0.
+ * @return the value of the logarithm, i.e. the number {@code y} such that
+ * basey = x.
+ * @since 3.0
+ */
+ public static double log(double base, double x) {
+ return log(x) / log(base);
+ }
+
+ /**
+ * Power function. Compute x^y.
+ *
+ * @param x a double
+ * @param y a double
+ * @return double
+ */
+ public static double pow(final double x, final double y) {
+
+ if (y == 0) {
+ // y = -0 or y = +0
+ return 1.0;
+ } else {
+
+ final long yBits = Double.doubleToRawLongBits(y);
+ final int yRawExp = (int) ((yBits & MASK_DOUBLE_EXPONENT) >> 52);
+ final long yRawMantissa = yBits & MASK_DOUBLE_MANTISSA;
+ final long xBits = Double.doubleToRawLongBits(x);
+ final int xRawExp = (int) ((xBits & MASK_DOUBLE_EXPONENT) >> 52);
+ final long xRawMantissa = xBits & MASK_DOUBLE_MANTISSA;
+
+ if (yRawExp > 1085) {
+ // y is either a very large integral value that does not fit in a long or it is a special number
+
+ if ((yRawExp == 2047 && yRawMantissa != 0) ||
+ (xRawExp == 2047 && xRawMantissa != 0)) {
+ // NaN
+ return Double.NaN;
+ } else if (xRawExp == 1023 && xRawMantissa == 0) {
+ // x = -1.0 or x = +1.0
+ if (yRawExp == 2047) {
+ // y is infinite
+ return Double.NaN;
+ } else {
+ // y is a large even integer
+ return 1.0;
+ }
+ } else {
+ // the absolute value of x is either greater or smaller than 1.0
+
+ // if yRawExp == 2047 and mantissa is 0, y = -infinity or y = +infinity
+ // if 1085 < yRawExp < 2047, y is simply a large number, however, due to limited
+ // accuracy, at this magnitude it behaves just like infinity with regards to x
+ if ((y > 0) ^ (xRawExp < 1023)) {
+ // either y = +infinity (or large engouh) and abs(x) > 1.0
+ // or y = -infinity (or large engouh) and abs(x) < 1.0
+ return Double.POSITIVE_INFINITY;
+ } else {
+ // either y = +infinity (or large engouh) and abs(x) < 1.0
+ // or y = -infinity (or large engouh) and abs(x) > 1.0
+ return +0.0;
+ }
+ }
+
+ } else {
+ // y is a regular non-zero number
+
+ if (yRawExp >= 1023) {
+ // y may be an integral value, which should be handled specifically
+ final long yFullMantissa = IMPLICIT_HIGH_BIT | yRawMantissa;
+ if (yRawExp < 1075) {
+ // normal number with negative shift that may have a fractional part
+ final long integralMask = (-1L) << (1075 - yRawExp);
+ if ((yFullMantissa & integralMask) == yFullMantissa) {
+ // all fractional bits are 0, the number is really integral
+ final long l = yFullMantissa >> (1075 - yRawExp);
+ return AccurateMath.pow(x, (y < 0) ? -l : l);
+ }
+ } else {
+ // normal number with positive shift, always an integral value
+ // we know it fits in a primitive long because yRawExp > 1085 has been handled above
+ final long l = yFullMantissa << (yRawExp - 1075);
+ return AccurateMath.pow(x, (y < 0) ? -l : l);
+ }
+ }
+
+ // y is a non-integral value
+
+ if (x == 0) {
+ // x = -0 or x = +0
+ // the integer powers have already been handled above
+ return y < 0 ? Double.POSITIVE_INFINITY : +0.0;
+ } else if (xRawExp == 2047) {
+ if (xRawMantissa == 0) {
+ // x = -infinity or x = +infinity
+ return (y < 0) ? +0.0 : Double.POSITIVE_INFINITY;
+ } else {
+ // NaN
+ return Double.NaN;
+ }
+ } else if (x < 0) {
+ // the integer powers have already been handled above
+ return Double.NaN;
+ } else {
+
+ // this is the general case, for regular fractional numbers x and y
+
+ // Split y into ya and yb such that y = ya+yb
+ final double tmp = y * HEX_40000000;
+ final double ya = (y + tmp) - tmp;
+ final double yb = y - ya;
+
+ /* Compute ln(x) */
+ final double lns[] = new double[2];
+ final double lores = log(x, lns);
+ if (Double.isInfinite(lores)) { // don't allow this to be converted to NaN
+ return lores;
+ }
+
+ double lna = lns[0];
+ double lnb = lns[1];
+
+ /* resplit lns */
+ final double tmp1 = lna * HEX_40000000;
+ final double tmp2 = (lna + tmp1) - tmp1;
+ lnb += lna - tmp2;
+ lna = tmp2;
+
+ // y*ln(x) = (aa+ab)
+ final double aa = lna * ya;
+ final double ab = lna * yb + lnb * ya + lnb * yb;
+
+ lna = aa+ab;
+ lnb = -(lna - aa - ab);
+
+ double z = 1.0 / 120.0;
+ z = z * lnb + (1.0 / 24.0);
+ z = z * lnb + (1.0 / 6.0);
+ z = z * lnb + 0.5;
+ z = z * lnb + 1.0;
+ z *= lnb;
+
+ final double result = exp(lna, z, null);
+ //result = result + result * z;
+ return result;
+
+ }
+ }
+
+ }
+
+ }
+
+ /**
+ * Raise a double to an int power.
+ *
+ * @param d Number to raise.
+ * @param e Exponent.
+ * @return de
+ * @since 3.1
+ */
+ public static double pow(double d, int e) {
+ return pow(d, (long) e);
+ }
+
+
+ /**
+ * Raise a double to a long power.
+ *
+ * @param d Number to raise.
+ * @param e Exponent.
+ * @return de
+ * @since 3.6
+ */
+ public static double pow(double d, long e) {
+ if (e == 0) {
+ return 1.0;
+ } else if (e > 0) {
+ return new Split(d).pow(e).full;
+ } else {
+ return new Split(d).reciprocal().pow(-e).full;
+ }
+ }
+
+ /** Class operator on double numbers split into one 26 bits number and one 27 bits number. */
+ private static class Split {
+
+ /** Split version of NaN. */
+ public static final Split NAN = new Split(Double.NaN, 0);
+
+ /** Split version of positive infinity. */
+ public static final Split POSITIVE_INFINITY = new Split(Double.POSITIVE_INFINITY, 0);
+
+ /** Split version of negative infinity. */
+ public static final Split NEGATIVE_INFINITY = new Split(Double.NEGATIVE_INFINITY, 0);
+
+ /** Full number. */
+ private final double full;
+
+ /** High order bits. */
+ private final double high;
+
+ /** Low order bits. */
+ private final double low;
+
+ /** Simple constructor.
+ * @param x number to split
+ */
+ Split(final double x) {
+ full = x;
+ high = Double.longBitsToDouble(Double.doubleToRawLongBits(x) & ((-1L) << 27));
+ low = x - high;
+ }
+
+ /** Simple constructor.
+ * @param high high order bits
+ * @param low low order bits
+ */
+ Split(final double high, final double low) {
+ this(high == 0.0 ? (low == 0.0 && Double.doubleToRawLongBits(high) == Long.MIN_VALUE /* negative zero */ ? -0.0 : low) : high + low, high, low);
+ }
+
+ /** Simple constructor.
+ * @param full full number
+ * @param high high order bits
+ * @param low low order bits
+ */
+ Split(final double full, final double high, final double low) {
+ this.full = full;
+ this.high = high;
+ this.low = low;
+ }
+
+ /** Multiply the instance by another one.
+ * @param b other instance to multiply by
+ * @return product
+ */
+ public Split multiply(final Split b) {
+ // beware the following expressions must NOT be simplified, they rely on floating point arithmetic properties
+ final Split mulBasic = new Split(full * b.full);
+ final double mulError = low * b.low - (((mulBasic.full - high * b.high) - low * b.high) - high * b.low);
+ return new Split(mulBasic.high, mulBasic.low + mulError);
+ }
+
+ /** Compute the reciprocal of the instance.
+ * @return reciprocal of the instance
+ */
+ public Split reciprocal() {
+
+ final double approximateInv = 1.0 / full;
+ final Split splitInv = new Split(approximateInv);
+
+ // if 1.0/d were computed perfectly, remultiplying it by d should give 1.0
+ // we want to estimate the error so we can fix the low order bits of approximateInvLow
+ // beware the following expressions must NOT be simplified, they rely on floating point arithmetic properties
+ final Split product = multiply(splitInv);
+ final double error = (product.high - 1) + product.low;
+
+ // better accuracy estimate of reciprocal
+ return Double.isNaN(error) ? splitInv : new Split(splitInv.high, splitInv.low - error / full);
+
+ }
+
+ /** Computes this^e.
+ * @param e exponent (beware, here it MUST be > 0; the only exclusion is Long.MIN_VALUE)
+ * @return d^e, split in high and low bits
+ * @since 3.6
+ */
+ private Split pow(final long e) {
+
+ // prepare result
+ Split result = new Split(1);
+
+ // d^(2p)
+ Split d2p = new Split(full, high, low);
+
+ for (long p = e; p != 0; p >>>= 1) {
+
+ if ((p & 0x1) != 0) {
+ // accurate multiplication result = result * d^(2p) using Veltkamp TwoProduct algorithm
+ result = result.multiply(d2p);
+ }
+
+ // accurate squaring d^(2(p+1)) = d^(2p) * d^(2p) using Veltkamp TwoProduct algorithm
+ d2p = d2p.multiply(d2p);
+
+ }
+
+ if (Double.isNaN(result.full)) {
+ if (Double.isNaN(full)) {
+ return Split.NAN;
+ } else {
+ // some intermediate numbers exceeded capacity,
+ // and the low order bits became NaN (because infinity - infinity = NaN)
+ if (AccurateMath.abs(full) < 1) {
+ return new Split(AccurateMath.copySign(0.0, full), 0.0);
+ } else if (full < 0 && (e & 0x1) == 1) {
+ return Split.NEGATIVE_INFINITY;
+ } else {
+ return Split.POSITIVE_INFINITY;
+ }
+ }
+ } else {
+ return result;
+ }
+
+ }
+
+ }
+
+ /**
+ * Computes sin(x) - x, where |x| < 1/16.
+ * Use a Remez polynomial approximation.
+ * @param x a number smaller than 1/16
+ * @return sin(x) - x
+ */
+ private static double polySine(final double x)
+ {
+ double x2 = x*x;
+
+ double p = 2.7553817452272217E-6;
+ p = p * x2 + -1.9841269659586505E-4;
+ p = p * x2 + 0.008333333333329196;
+ p = p * x2 + -0.16666666666666666;
+ //p *= x2;
+ //p *= x;
+ p = p * x2 * x;
+
+ return p;
+ }
+
+ /**
+ * Computes cos(x) - 1, where |x| < 1/16.
+ * Use a Remez polynomial approximation.
+ * @param x a number smaller than 1/16
+ * @return cos(x) - 1
+ */
+ private static double polyCosine(double x) {
+ double x2 = x*x;
+
+ double p = 2.479773539153719E-5;
+ p = p * x2 + -0.0013888888689039883;
+ p = p * x2 + 0.041666666666621166;
+ p = p * x2 + -0.49999999999999994;
+ p *= x2;
+
+ return p;
+ }
+
+ /**
+ * Compute sine over the first quadrant (0 < x < pi/2).
+ * Use combination of table lookup and rational polynomial expansion.
+ * @param xa number from which sine is requested
+ * @param xb extra bits for x (may be 0.0)
+ * @return sin(xa + xb)
+ */
+ private static double sinQ(double xa, double xb) {
+ int idx = (int) ((xa * 8.0) + 0.5);
+ final double epsilon = xa - EIGHTHS[idx]; //idx*0.125;
+
+ // Table lookups
+ final double sintA = SINE_TABLE_A[idx];
+ final double sintB = SINE_TABLE_B[idx];
+ final double costA = COSINE_TABLE_A[idx];
+ final double costB = COSINE_TABLE_B[idx];
+
+ // Polynomial eval of sin(epsilon), cos(epsilon)
+ double sinEpsA = epsilon;
+ double sinEpsB = polySine(epsilon);
+ final double cosEpsA = 1.0;
+ final double cosEpsB = polyCosine(epsilon);
+
+ // Split epsilon xa + xb = x
+ final double temp = sinEpsA * HEX_40000000;
+ double temp2 = (sinEpsA + temp) - temp;
+ sinEpsB += sinEpsA - temp2;
+ sinEpsA = temp2;
+
+ /* Compute sin(x) by angle addition formula */
+ double result;
+
+ /* Compute the following sum:
+ *
+ * result = sintA + costA*sinEpsA + sintA*cosEpsB + costA*sinEpsB +
+ * sintB + costB*sinEpsA + sintB*cosEpsB + costB*sinEpsB;
+ *
+ * Ranges of elements
+ *
+ * xxxtA 0 PI/2
+ * xxxtB -1.5e-9 1.5e-9
+ * sinEpsA -0.0625 0.0625
+ * sinEpsB -6e-11 6e-11
+ * cosEpsA 1.0
+ * cosEpsB 0 -0.0625
+ *
+ */
+
+ //result = sintA + costA*sinEpsA + sintA*cosEpsB + costA*sinEpsB +
+ // sintB + costB*sinEpsA + sintB*cosEpsB + costB*sinEpsB;
+
+ //result = sintA + sintA*cosEpsB + sintB + sintB * cosEpsB;
+ //result += costA*sinEpsA + costA*sinEpsB + costB*sinEpsA + costB * sinEpsB;
+ double a = 0;
+ double b = 0;
+
+ double t = sintA;
+ double c = a + t;
+ double d = -(c - a - t);
+ a = c;
+ b += d;
+
+ t = costA * sinEpsA;
+ c = a + t;
+ d = -(c - a - t);
+ a = c;
+ b += d;
+
+ b = b + sintA * cosEpsB + costA * sinEpsB;
+ /*
+ t = sintA*cosEpsB;
+ c = a + t;
+ d = -(c - a - t);
+ a = c;
+ b = b + d;
+
+ t = costA*sinEpsB;
+ c = a + t;
+ d = -(c - a - t);
+ a = c;
+ b = b + d;
+ */
+
+ b = b + sintB + costB * sinEpsA + sintB * cosEpsB + costB * sinEpsB;
+ /*
+ t = sintB;
+ c = a + t;
+ d = -(c - a - t);
+ a = c;
+ b = b + d;
+
+ t = costB*sinEpsA;
+ c = a + t;
+ d = -(c - a - t);
+ a = c;
+ b = b + d;
+
+ t = sintB*cosEpsB;
+ c = a + t;
+ d = -(c - a - t);
+ a = c;
+ b = b + d;
+
+ t = costB*sinEpsB;
+ c = a + t;
+ d = -(c - a - t);
+ a = c;
+ b = b + d;
+ */
+
+ if (xb != 0.0) {
+ t = ((costA + costB) * (cosEpsA + cosEpsB) -
+ (sintA + sintB) * (sinEpsA + sinEpsB)) * xb; // approximate cosine*xb
+ c = a + t;
+ d = -(c - a - t);
+ a = c;
+ b += d;
+ }
+
+ result = a + b;
+
+ return result;
+ }
+
+ /**
+ * Compute cosine in the first quadrant by subtracting input from PI/2 and
+ * then calling sinQ. This is more accurate as the input approaches PI/2.
+ * @param xa number from which cosine is requested
+ * @param xb extra bits for x (may be 0.0)
+ * @return cos(xa + xb)
+ */
+ private static double cosQ(double xa, double xb) {
+ final double pi2a = 1.5707963267948966;
+ final double pi2b = 6.123233995736766E-17;
+
+ final double a = pi2a - xa;
+ double b = -(a - pi2a + xa);
+ b += pi2b - xb;
+
+ return sinQ(a, b);
+ }
+
+ /**
+ * Compute tangent (or cotangent) over the first quadrant. 0 < x < pi/2
+ * Use combination of table lookup and rational polynomial expansion.
+ * @param xa number from which sine is requested
+ * @param xb extra bits for x (may be 0.0)
+ * @param cotanFlag if true, compute the cotangent instead of the tangent
+ * @return tan(xa+xb) (or cotangent, depending on cotanFlag)
+ */
+ private static double tanQ(double xa, double xb, boolean cotanFlag) {
+
+ int idx = (int) ((xa * 8.0) + 0.5);
+ final double epsilon = xa - EIGHTHS[idx]; //idx*0.125;
+
+ // Table lookups
+ final double sintA = SINE_TABLE_A[idx];
+ final double sintB = SINE_TABLE_B[idx];
+ final double costA = COSINE_TABLE_A[idx];
+ final double costB = COSINE_TABLE_B[idx];
+
+ // Polynomial eval of sin(epsilon), cos(epsilon)
+ double sinEpsA = epsilon;
+ double sinEpsB = polySine(epsilon);
+ final double cosEpsA = 1.0;
+ final double cosEpsB = polyCosine(epsilon);
+
+ // Split epsilon xa + xb = x
+ double temp = sinEpsA * HEX_40000000;
+ double temp2 = (sinEpsA + temp) - temp;
+ sinEpsB += sinEpsA - temp2;
+ sinEpsA = temp2;
+
+ /* Compute sin(x) by angle addition formula */
+
+ /* Compute the following sum:
+ *
+ * result = sintA + costA*sinEpsA + sintA*cosEpsB + costA*sinEpsB +
+ * sintB + costB*sinEpsA + sintB*cosEpsB + costB*sinEpsB;
+ *
+ * Ranges of elements
+ *
+ * xxxtA 0 PI/2
+ * xxxtB -1.5e-9 1.5e-9
+ * sinEpsA -0.0625 0.0625
+ * sinEpsB -6e-11 6e-11
+ * cosEpsA 1.0
+ * cosEpsB 0 -0.0625
+ *
+ */
+
+ //result = sintA + costA*sinEpsA + sintA*cosEpsB + costA*sinEpsB +
+ // sintB + costB*sinEpsA + sintB*cosEpsB + costB*sinEpsB;
+
+ //result = sintA + sintA*cosEpsB + sintB + sintB * cosEpsB;
+ //result += costA*sinEpsA + costA*sinEpsB + costB*sinEpsA + costB * sinEpsB;
+ double a = 0;
+ double b = 0;
+
+ // Compute sine
+ double t = sintA;
+ double c = a + t;
+ double d = -(c - a - t);
+ a = c;
+ b += d;
+
+ t = costA*sinEpsA;
+ c = a + t;
+ d = -(c - a - t);
+ a = c;
+ b += d;
+
+ b += sintA*cosEpsB + costA*sinEpsB;
+ b += sintB + costB*sinEpsA + sintB*cosEpsB + costB*sinEpsB;
+
+ double sina = a + b;
+ double sinb = -(sina - a - b);
+
+ // Compute cosine
+
+ a = b = c = d = 0.0;
+
+ t = costA*cosEpsA;
+ c = a + t;
+ d = -(c - a - t);
+ a = c;
+ b += d;
+
+ t = -sintA*sinEpsA;
+ c = a + t;
+ d = -(c - a - t);
+ a = c;
+ b += d;
+
+ b += costB*cosEpsA + costA*cosEpsB + costB*cosEpsB;
+ b -= sintB*sinEpsA + sintA*sinEpsB + sintB*sinEpsB;
+
+ double cosa = a + b;
+ double cosb = -(cosa - a - b);
+
+ if (cotanFlag) {
+ double tmp;
+ tmp = cosa; cosa = sina; sina = tmp;
+ tmp = cosb; cosb = sinb; sinb = tmp;
+ }
+
+
+ /* estimate and correct, compute 1.0/(cosa+cosb) */
+ /*
+ double est = (sina+sinb)/(cosa+cosb);
+ double err = (sina - cosa*est) + (sinb - cosb*est);
+ est += err/(cosa+cosb);
+ err = (sina - cosa*est) + (sinb - cosb*est);
+ */
+
+ // f(x) = 1/x, f'(x) = -1/x^2
+
+ double est = sina/cosa;
+
+ /* Split the estimate to get more accurate read on division rounding */
+ temp = est * HEX_40000000;
+ double esta = (est + temp) - temp;
+ double estb = est - esta;
+
+ temp = cosa * HEX_40000000;
+ double cosaa = (cosa + temp) - temp;
+ double cosab = cosa - cosaa;
+
+ //double err = (sina - est*cosa)/cosa; // Correction for division rounding
+ double err = (sina - esta*cosaa - esta*cosab - estb*cosaa - estb*cosab)/cosa; // Correction for division rounding
+ err += sinb/cosa; // Change in est due to sinb
+ err += -sina * cosb / cosa / cosa; // Change in est due to cosb
+
+ if (xb != 0.0) {
+ // tan' = 1 + tan^2 cot' = -(1 + cot^2)
+ // Approximate impact of xb
+ double xbadj = xb + est*est*xb;
+ if (cotanFlag) {
+ xbadj = -xbadj;
+ }
+
+ err += xbadj;
+ }
+
+ return est+err;
+ }
+
+ /** Reduce the input argument using the Payne and Hanek method.
+ * This is good for all inputs 0.0 < x < inf
+ * Output is remainder after dividing by PI/2
+ * The result array should contain 3 numbers.
+ * result[0] is the integer portion, so mod 4 this gives the quadrant.
+ * result[1] is the upper bits of the remainder
+ * result[2] is the lower bits of the remainder
+ *
+ * @param x number to reduce
+ * @param result placeholder where to put the result
+ */
+ private static void reducePayneHanek(double x, double result[])
+ {
+ /* Convert input double to bits */
+ long inbits = Double.doubleToRawLongBits(x);
+ int exponent = (int) ((inbits >> 52) & 0x7ff) - 1023;
+
+ /* Convert to fixed point representation */
+ inbits &= 0x000fffffffffffffL;
+ inbits |= 0x0010000000000000L;
+
+ /* Normalize input to be between 0.5 and 1.0 */
+ exponent++;
+ inbits <<= 11;
+
+ /* Based on the exponent, get a shifted copy of recip2pi */
+ long shpi0;
+ long shpiA;
+ long shpiB;
+ int idx = exponent >> 6;
+ int shift = exponent - (idx << 6);
+
+ if (shift != 0) {
+ shpi0 = (idx == 0) ? 0 : (RECIP_2PI[idx-1] << shift);
+ shpi0 |= RECIP_2PI[idx] >>> (64-shift);
+ shpiA = (RECIP_2PI[idx] << shift) | (RECIP_2PI[idx+1] >>> (64-shift));
+ shpiB = (RECIP_2PI[idx+1] << shift) | (RECIP_2PI[idx+2] >>> (64-shift));
+ } else {
+ shpi0 = (idx == 0) ? 0 : RECIP_2PI[idx-1];
+ shpiA = RECIP_2PI[idx];
+ shpiB = RECIP_2PI[idx+1];
+ }
+
+ /* Multiply input by shpiA */
+ long a = inbits >>> 32;
+ long b = inbits & 0xffffffffL;
+
+ long c = shpiA >>> 32;
+ long d = shpiA & 0xffffffffL;
+
+ long ac = a * c;
+ long bd = b * d;
+ long bc = b * c;
+ long ad = a * d;
+
+ long prodB = bd + (ad << 32);
+ long prodA = ac + (ad >>> 32);
+
+ boolean bita = (bd & 0x8000000000000000L) != 0;
+ boolean bitb = (ad & 0x80000000L ) != 0;
+ boolean bitsum = (prodB & 0x8000000000000000L) != 0;
+
+ /* Carry */
+ if ( (bita && bitb) ||
+ ((bita || bitb) && !bitsum) ) {
+ prodA++;
+ }
+
+ bita = (prodB & 0x8000000000000000L) != 0;
+ bitb = (bc & 0x80000000L ) != 0;
+
+ prodB += bc << 32;
+ prodA += bc >>> 32;
+
+ bitsum = (prodB & 0x8000000000000000L) != 0;
+
+ /* Carry */
+ if ( (bita && bitb) ||
+ ((bita || bitb) && !bitsum) ) {
+ prodA++;
+ }
+
+ /* Multiply input by shpiB */
+ c = shpiB >>> 32;
+ d = shpiB & 0xffffffffL;
+ ac = a * c;
+ bc = b * c;
+ ad = a * d;
+
+ /* Collect terms */
+ ac += (bc + ad) >>> 32;
+
+ bita = (prodB & 0x8000000000000000L) != 0;
+ bitb = (ac & 0x8000000000000000L ) != 0;
+ prodB += ac;
+ bitsum = (prodB & 0x8000000000000000L) != 0;
+ /* Carry */
+ if ( (bita && bitb) ||
+ ((bita || bitb) && !bitsum) ) {
+ prodA++;
+ }
+
+ /* Multiply by shpi0 */
+ c = shpi0 >>> 32;
+ d = shpi0 & 0xffffffffL;
+
+ bd = b * d;
+ bc = b * c;
+ ad = a * d;
+
+ prodA += bd + ((bc + ad) << 32);
+
+ /*
+ * prodA, prodB now contain the remainder as a fraction of PI. We want this as a fraction of
+ * PI/2, so use the following steps:
+ * 1.) multiply by 4.
+ * 2.) do a fixed point muliply by PI/4.
+ * 3.) Convert to floating point.
+ * 4.) Multiply by 2
+ */
+
+ /* This identifies the quadrant */
+ int intPart = (int)(prodA >>> 62);
+
+ /* Multiply by 4 */
+ prodA <<= 2;
+ prodA |= prodB >>> 62;
+ prodB <<= 2;
+
+ /* Multiply by PI/4 */
+ a = prodA >>> 32;
+ b = prodA & 0xffffffffL;
+
+ c = PI_O_4_BITS[0] >>> 32;
+ d = PI_O_4_BITS[0] & 0xffffffffL;
+
+ ac = a * c;
+ bd = b * d;
+ bc = b * c;
+ ad = a * d;
+
+ long prod2B = bd + (ad << 32);
+ long prod2A = ac + (ad >>> 32);
+
+ bita = (bd & 0x8000000000000000L) != 0;
+ bitb = (ad & 0x80000000L ) != 0;
+ bitsum = (prod2B & 0x8000000000000000L) != 0;
+
+ /* Carry */
+ if ( (bita && bitb) ||
+ ((bita || bitb) && !bitsum) ) {
+ prod2A++;
+ }
+
+ bita = (prod2B & 0x8000000000000000L) != 0;
+ bitb = (bc & 0x80000000L ) != 0;
+
+ prod2B += bc << 32;
+ prod2A += bc >>> 32;
+
+ bitsum = (prod2B & 0x8000000000000000L) != 0;
+
+ /* Carry */
+ if ( (bita && bitb) ||
+ ((bita || bitb) && !bitsum) ) {
+ prod2A++;
+ }
+
+ /* Multiply input by pio4bits[1] */
+ c = PI_O_4_BITS[1] >>> 32;
+ d = PI_O_4_BITS[1] & 0xffffffffL;
+ ac = a * c;
+ bc = b * c;
+ ad = a * d;
+
+ /* Collect terms */
+ ac += (bc + ad) >>> 32;
+
+ bita = (prod2B & 0x8000000000000000L) != 0;
+ bitb = (ac & 0x8000000000000000L ) != 0;
+ prod2B += ac;
+ bitsum = (prod2B & 0x8000000000000000L) != 0;
+ /* Carry */
+ if ( (bita && bitb) ||
+ ((bita || bitb) && !bitsum) ) {
+ prod2A++;
+ }
+
+ /* Multiply inputB by pio4bits[0] */
+ a = prodB >>> 32;
+ b = prodB & 0xffffffffL;
+ c = PI_O_4_BITS[0] >>> 32;
+ d = PI_O_4_BITS[0] & 0xffffffffL;
+ ac = a * c;
+ bc = b * c;
+ ad = a * d;
+
+ /* Collect terms */
+ ac += (bc + ad) >>> 32;
+
+ bita = (prod2B & 0x8000000000000000L) != 0;
+ bitb = (ac & 0x8000000000000000L ) != 0;
+ prod2B += ac;
+ bitsum = (prod2B & 0x8000000000000000L) != 0;
+ /* Carry */
+ if ( (bita && bitb) ||
+ ((bita || bitb) && !bitsum) ) {
+ prod2A++;
+ }
+
+ /* Convert to double */
+ double tmpA = (prod2A >>> 12) / TWO_POWER_52; // High order 52 bits
+ double tmpB = (((prod2A & 0xfffL) << 40) + (prod2B >>> 24)) / TWO_POWER_52 / TWO_POWER_52; // Low bits
+
+ double sumA = tmpA + tmpB;
+ double sumB = -(sumA - tmpA - tmpB);
+
+ /* Multiply by PI/2 and return */
+ result[0] = intPart;
+ result[1] = sumA * 2.0;
+ result[2] = sumB * 2.0;
+ }
+
+ /**
+ * Sine function.
+ *
+ * @param x Argument.
+ * @return sin(x)
+ */
+ public static double sin(double x) {
+ boolean negative = false;
+ int quadrant = 0;
+ double xa;
+ double xb = 0.0;
+
+ /* Take absolute value of the input */
+ xa = x;
+ if (x < 0) {
+ negative = true;
+ xa = -xa;
+ }
+
+ /* Check for zero and negative zero */
+ if (xa == 0.0) {
+ long bits = Double.doubleToRawLongBits(x);
+ if (bits < 0) {
+ return -0.0;
+ }
+ return 0.0;
+ }
+
+ if (xa != xa || xa == Double.POSITIVE_INFINITY) {
+ return Double.NaN;
+ }
+
+ /* Perform any argument reduction */
+ if (xa > 3294198.0) {
+ // PI * (2**20)
+ // Argument too big for CodyWaite reduction. Must use
+ // PayneHanek.
+ double reduceResults[] = new double[3];
+ reducePayneHanek(xa, reduceResults);
+ quadrant = ((int) reduceResults[0]) & 3;
+ xa = reduceResults[1];
+ xb = reduceResults[2];
+ } else if (xa > 1.5707963267948966) {
+ final CodyWaite cw = new CodyWaite(xa);
+ quadrant = cw.getK() & 3;
+ xa = cw.getRemA();
+ xb = cw.getRemB();
+ }
+
+ if (negative) {
+ quadrant ^= 2; // Flip bit 1
+ }
+
+ switch (quadrant) {
+ case 0:
+ return sinQ(xa, xb);
+ case 1:
+ return cosQ(xa, xb);
+ case 2:
+ return -sinQ(xa, xb);
+ case 3:
+ return -cosQ(xa, xb);
+ default:
+ return Double.NaN;
+ }
+ }
+
+ /**
+ * Cosine function.
+ *
+ * @param x Argument.
+ * @return cos(x)
+ */
+ public static double cos(double x) {
+ int quadrant = 0;
+
+ /* Take absolute value of the input */
+ double xa = x;
+ if (x < 0) {
+ xa = -xa;
+ }
+
+ if (xa != xa || xa == Double.POSITIVE_INFINITY) {
+ return Double.NaN;
+ }
+
+ /* Perform any argument reduction */
+ double xb = 0;
+ if (xa > 3294198.0) {
+ // PI * (2**20)
+ // Argument too big for CodyWaite reduction. Must use
+ // PayneHanek.
+ double reduceResults[] = new double[3];
+ reducePayneHanek(xa, reduceResults);
+ quadrant = ((int) reduceResults[0]) & 3;
+ xa = reduceResults[1];
+ xb = reduceResults[2];
+ } else if (xa > 1.5707963267948966) {
+ final CodyWaite cw = new CodyWaite(xa);
+ quadrant = cw.getK() & 3;
+ xa = cw.getRemA();
+ xb = cw.getRemB();
+ }
+
+ //if (negative)
+ // quadrant = (quadrant + 2) % 4;
+
+ switch (quadrant) {
+ case 0:
+ return cosQ(xa, xb);
+ case 1:
+ return -sinQ(xa, xb);
+ case 2:
+ return -cosQ(xa, xb);
+ case 3:
+ return sinQ(xa, xb);
+ default:
+ return Double.NaN;
+ }
+ }
+
+ /**
+ * Tangent function.
+ *
+ * @param x Argument.
+ * @return tan(x)
+ */
+ public static double tan(double x) {
+ boolean negative = false;
+ int quadrant = 0;
+
+ /* Take absolute value of the input */
+ double xa = x;
+ if (x < 0) {
+ negative = true;
+ xa = -xa;
+ }
+
+ /* Check for zero and negative zero */
+ if (xa == 0.0) {
+ long bits = Double.doubleToRawLongBits(x);
+ if (bits < 0) {
+ return -0.0;
+ }
+ return 0.0;
+ }
+
+ if (xa != xa || xa == Double.POSITIVE_INFINITY) {
+ return Double.NaN;
+ }
+
+ /* Perform any argument reduction */
+ double xb = 0;
+ if (xa > 3294198.0) {
+ // PI * (2**20)
+ // Argument too big for CodyWaite reduction. Must use
+ // PayneHanek.
+ double reduceResults[] = new double[3];
+ reducePayneHanek(xa, reduceResults);
+ quadrant = ((int) reduceResults[0]) & 3;
+ xa = reduceResults[1];
+ xb = reduceResults[2];
+ } else if (xa > 1.5707963267948966) {
+ final CodyWaite cw = new CodyWaite(xa);
+ quadrant = cw.getK() & 3;
+ xa = cw.getRemA();
+ xb = cw.getRemB();
+ }
+
+ if (xa > 1.5) {
+ // Accuracy suffers between 1.5 and PI/2
+ final double pi2a = 1.5707963267948966;
+ final double pi2b = 6.123233995736766E-17;
+
+ final double a = pi2a - xa;
+ double b = -(a - pi2a + xa);
+ b += pi2b - xb;
+
+ xa = a + b;
+ xb = -(xa - a - b);
+ quadrant ^= 1;
+ negative ^= true;
+ }
+
+ double result;
+ if ((quadrant & 1) == 0) {
+ result = tanQ(xa, xb, false);
+ } else {
+ result = -tanQ(xa, xb, true);
+ }
+
+ if (negative) {
+ result = -result;
+ }
+
+ return result;
+ }
+
+ /**
+ * Arctangent function
+ * @param x a number
+ * @return atan(x)
+ */
+ public static double atan(double x) {
+ return atan(x, 0.0, false);
+ }
+
+ /** Internal helper function to compute arctangent.
+ * @param xa number from which arctangent is requested
+ * @param xb extra bits for x (may be 0.0)
+ * @param leftPlane if true, result angle must be put in the left half plane
+ * @return atan(xa + xb) (or angle shifted by {@code PI} if leftPlane is true)
+ */
+ private static double atan(double xa, double xb, boolean leftPlane) {
+ if (xa == 0.0) { // Matches +/- 0.0; return correct sign
+ return leftPlane ? copySign(Math.PI, xa) : xa;
+ }
+
+ final boolean negate;
+ if (xa < 0) {
+ // negative
+ xa = -xa;
+ xb = -xb;
+ negate = true;
+ } else {
+ negate = false;
+ }
+
+ if (xa > 1.633123935319537E16) { // Very large input
+ return (negate ^ leftPlane) ? (-Math.PI * F_1_2) : (Math.PI * F_1_2);
+ }
+
+ /* Estimate the closest tabulated arctan value, compute eps = xa-tangentTable */
+ final int idx;
+ if (xa < 1) {
+ idx = (int) (((-1.7168146928204136 * xa * xa + 8.0) * xa) + 0.5);
+ } else {
+ final double oneOverXa = 1 / xa;
+ idx = (int) (-((-1.7168146928204136 * oneOverXa * oneOverXa + 8.0) * oneOverXa) + 13.07);
+ }
+
+ final double ttA = TANGENT_TABLE_A[idx];
+ final double ttB = TANGENT_TABLE_B[idx];
+
+ double epsA = xa - ttA;
+ double epsB = -(epsA - xa + ttA);
+ epsB += xb - ttB;
+
+ double temp = epsA + epsB;
+ epsB = -(temp - epsA - epsB);
+ epsA = temp;
+
+ /* Compute eps = eps / (1.0 + xa*tangent) */
+ temp = xa * HEX_40000000;
+ double ya = xa + temp - temp;
+ double yb = xb + xa - ya;
+ xa = ya;
+ xb += yb;
+
+ //if (idx > 8 || idx == 0)
+ if (idx == 0) {
+ /* If the slope of the arctan is gentle enough (< 0.45), this approximation will suffice */
+ //double denom = 1.0 / (1.0 + xa*tangentTableA[idx] + xb*tangentTableA[idx] + xa*tangentTableB[idx] + xb*tangentTableB[idx]);
+ final double denom = 1d / (1d + (xa + xb) * (ttA + ttB));
+ //double denom = 1.0 / (1.0 + xa*tangentTableA[idx]);
+ ya = epsA * denom;
+ yb = epsB * denom;
+ } else {
+ double temp2 = xa * ttA;
+ double za = 1d + temp2;
+ double zb = -(za - 1d - temp2);
+ temp2 = xb * ttA + xa * ttB;
+ temp = za + temp2;
+ zb += -(temp - za - temp2);
+ za = temp;
+
+ zb += xb * ttB;
+ ya = epsA / za;
+
+ temp = ya * HEX_40000000;
+ final double yaa = (ya + temp) - temp;
+ final double yab = ya - yaa;
+
+ temp = za * HEX_40000000;
+ final double zaa = (za + temp) - temp;
+ final double zab = za - zaa;
+
+ /* Correct for rounding in division */
+ yb = (epsA - yaa * zaa - yaa * zab - yab * zaa - yab * zab) / za;
+
+ yb += -epsA * zb / za / za;
+ yb += epsB / za;
+ }
+
+
+ epsA = ya;
+ epsB = yb;
+
+ /* Evaluate polynomial */
+ final double epsA2 = epsA * epsA;
+
+ /*
+ yb = -0.09001346640161823;
+ yb = yb * epsA2 + 0.11110718400605211;
+ yb = yb * epsA2 + -0.1428571349122913;
+ yb = yb * epsA2 + 0.19999999999273194;
+ yb = yb * epsA2 + -0.33333333333333093;
+ yb = yb * epsA2 * epsA;
+ */
+
+ yb = 0.07490822288864472;
+ yb = yb * epsA2 - 0.09088450866185192;
+ yb = yb * epsA2 + 0.11111095942313305;
+ yb = yb * epsA2 - 0.1428571423679182;
+ yb = yb * epsA2 + 0.19999999999923582;
+ yb = yb * epsA2 - 0.33333333333333287;
+ yb = yb * epsA2 * epsA;
+
+
+ ya = epsA;
+
+ temp = ya + yb;
+ yb = -(temp - ya - yb);
+ ya = temp;
+
+ /* Add in effect of epsB. atan'(x) = 1/(1+x^2) */
+ yb += epsB / (1d + epsA * epsA);
+
+ final double eighths = EIGHTHS[idx];
+
+ //result = yb + eighths[idx] + ya;
+ double za = eighths + ya;
+ double zb = -(za - eighths - ya);
+ temp = za + yb;
+ zb += -(temp - za - yb);
+ za = temp;
+
+ double result = za + zb;
+
+ if (leftPlane) {
+ // Result is in the left plane
+ final double resultb = -(result - za - zb);
+ final double pia = 1.5707963267948966 * 2;
+ final double pib = 6.123233995736766E-17 * 2;
+
+ za = pia - result;
+ zb = -(za - pia + result);
+ zb += pib - resultb;
+
+ result = za + zb;
+ }
+
+
+ if (negate ^ leftPlane) {
+ result = -result;
+ }
+
+ return result;
+ }
+
+ /**
+ * Two arguments arctangent function
+ * @param y ordinate
+ * @param x abscissa
+ * @return phase angle of point (x,y) between {@code -PI} and {@code PI}
+ */
+ public static double atan2(double y, double x) {
+ if (Double.isNaN(x) || Double.isNaN(y)) {
+ return Double.NaN;
+ }
+
+ if (y == 0) {
+ final double result = x * y;
+ final double invx = 1d / x;
+ final double invy = 1d / y;
+
+ if (invx == 0) { // X is infinite
+ if (x > 0) {
+ return y; // return +/- 0.0
+ } else {
+ return copySign(Math.PI, y);
+ }
+ }
+
+ if (x < 0 || invx < 0) {
+ if (y < 0 || invy < 0) {
+ return -Math.PI;
+ } else {
+ return Math.PI;
+ }
+ } else {
+ return result;
+ }
+ }
+
+ // y cannot now be zero
+
+ if (y == Double.POSITIVE_INFINITY) {
+ if (x == Double.POSITIVE_INFINITY) {
+ return Math.PI * F_1_4;
+ }
+
+ if (x == Double.NEGATIVE_INFINITY) {
+ return Math.PI * F_3_4;
+ }
+
+ return Math.PI * F_1_2;
+ }
+
+ if (y == Double.NEGATIVE_INFINITY) {
+ if (x == Double.POSITIVE_INFINITY) {
+ return -Math.PI * F_1_4;
+ }
+
+ if (x == Double.NEGATIVE_INFINITY) {
+ return -Math.PI * F_3_4;
+ }
+
+ return -Math.PI * F_1_2;
+ }
+
+ if (x == Double.POSITIVE_INFINITY) {
+ if (y > 0 || 1 / y > 0) {
+ return 0d;
+ }
+
+ if (y < 0 || 1 / y < 0) {
+ return -0d;
+ }
+ }
+
+ if (x == Double.NEGATIVE_INFINITY)
+ {
+ if (y > 0.0 || 1 / y > 0.0) {
+ return Math.PI;
+ }
+
+ if (y < 0 || 1 / y < 0) {
+ return -Math.PI;
+ }
+ }
+
+ // Neither y nor x can be infinite or NAN here
+
+ if (x == 0) {
+ if (y > 0 || 1 / y > 0) {
+ return Math.PI * F_1_2;
+ }
+
+ if (y < 0 || 1 / y < 0) {
+ return -Math.PI * F_1_2;
+ }
+ }
+
+ // Compute ratio r = y/x
+ final double r = y / x;
+ if (Double.isInfinite(r)) { // bypass calculations that can create NaN
+ return atan(r, 0, x < 0);
+ }
+
+ double ra = doubleHighPart(r);
+ double rb = r - ra;
+
+ // Split x
+ final double xa = doubleHighPart(x);
+ final double xb = x - xa;
+
+ rb += (y - ra * xa - ra * xb - rb * xa - rb * xb) / x;
+
+ final double temp = ra + rb;
+ rb = -(temp - ra - rb);
+ ra = temp;
+
+ if (ra == 0) { // Fix up the sign so atan works correctly
+ ra = copySign(0d, y);
+ }
+
+ // Call atan
+ final double result = atan(ra, rb, x < 0);
+
+ return result;
+ }
+
+ /** Compute the arc sine of a number.
+ * @param x number on which evaluation is done
+ * @return arc sine of x
+ */
+ public static double asin(double x) {
+ if (Double.isNaN(x)) {
+ return Double.NaN;
+ }
+
+ if (x > 1.0 || x < -1.0) {
+ return Double.NaN;
+ }
+
+ if (x == 1.0) {
+ return Math.PI/2.0;
+ }
+
+ if (x == -1.0) {
+ return -Math.PI/2.0;
+ }
+
+ if (x == 0.0) { // Matches +/- 0.0; return correct sign
+ return x;
+ }
+
+ /* Compute asin(x) = atan(x/sqrt(1-x*x)) */
+
+ /* Split x */
+ double temp = x * HEX_40000000;
+ final double xa = x + temp - temp;
+ final double xb = x - xa;
+
+ /* Square it */
+ double ya = xa*xa;
+ double yb = xa*xb*2.0 + xb*xb;
+
+ /* Subtract from 1 */
+ ya = -ya;
+ yb = -yb;
+
+ double za = 1.0 + ya;
+ double zb = -(za - 1.0 - ya);
+
+ temp = za + yb;
+ zb += -(temp - za - yb);
+ za = temp;
+
+ /* Square root */
+ double y;
+ y = sqrt(za);
+ temp = y * HEX_40000000;
+ ya = y + temp - temp;
+ yb = y - ya;
+
+ /* Extend precision of sqrt */
+ yb += (za - ya*ya - 2*ya*yb - yb*yb) / (2.0*y);
+
+ /* Contribution of zb to sqrt */
+ double dx = zb / (2.0*y);
+
+ // Compute ratio r = x/y
+ double r = x/y;
+ temp = r * HEX_40000000;
+ double ra = r + temp - temp;
+ double rb = r - ra;
+
+ rb += (x - ra*ya - ra*yb - rb*ya - rb*yb) / y; // Correct for rounding in division
+ rb += -x * dx / y / y; // Add in effect additional bits of sqrt.
+
+ temp = ra + rb;
+ rb = -(temp - ra - rb);
+ ra = temp;
+
+ return atan(ra, rb, false);
+ }
+
+ /** Compute the arc cosine of a number.
+ * @param x number on which evaluation is done
+ * @return arc cosine of x
+ */
+ public static double acos(double x) {
+ if (Double.isNaN(x)) {
+ return Double.NaN;
+ }
+
+ if (x > 1.0 || x < -1.0) {
+ return Double.NaN;
+ }
+
+ if (x == -1.0) {
+ return Math.PI;
+ }
+
+ if (x == 1.0) {
+ return 0.0;
+ }
+
+ if (x == 0) {
+ return Math.PI/2.0;
+ }
+
+ /* Compute acos(x) = atan(sqrt(1-x*x)/x) */
+
+ /* Split x */
+ double temp = x * HEX_40000000;
+ final double xa = x + temp - temp;
+ final double xb = x - xa;
+
+ /* Square it */
+ double ya = xa*xa;
+ double yb = xa*xb*2.0 + xb*xb;
+
+ /* Subtract from 1 */
+ ya = -ya;
+ yb = -yb;
+
+ double za = 1.0 + ya;
+ double zb = -(za - 1.0 - ya);
+
+ temp = za + yb;
+ zb += -(temp - za - yb);
+ za = temp;
+
+ /* Square root */
+ double y = sqrt(za);
+ temp = y * HEX_40000000;
+ ya = y + temp - temp;
+ yb = y - ya;
+
+ /* Extend precision of sqrt */
+ yb += (za - ya*ya - 2*ya*yb - yb*yb) / (2.0*y);
+
+ /* Contribution of zb to sqrt */
+ yb += zb / (2.0*y);
+ y = ya+yb;
+ yb = -(y - ya - yb);
+
+ // Compute ratio r = y/x
+ double r = y/x;
+
+ // Did r overflow?
+ if (Double.isInfinite(r)) { // x is effectively zero
+ return Math.PI/2; // so return the appropriate value
+ }
+
+ double ra = doubleHighPart(r);
+ double rb = r - ra;
+
+ rb += (y - ra*xa - ra*xb - rb*xa - rb*xb) / x; // Correct for rounding in division
+ rb += yb / x; // Add in effect additional bits of sqrt.
+
+ temp = ra + rb;
+ rb = -(temp - ra - rb);
+ ra = temp;
+
+ return atan(ra, rb, x<0);
+ }
+
+ /** Compute the cubic root of a number.
+ * @param x number on which evaluation is done
+ * @return cubic root of x
+ */
+ public static double cbrt(double x) {
+ /* Convert input double to bits */
+ long inbits = Double.doubleToRawLongBits(x);
+ int exponent = (int) ((inbits >> 52) & 0x7ff) - 1023;
+ boolean subnormal = false;
+
+ if (exponent == -1023) {
+ if (x == 0) {
+ return x;
+ }
+
+ /* Subnormal, so normalize */
+ subnormal = true;
+ x *= 1.8014398509481984E16; // 2^54
+ inbits = Double.doubleToRawLongBits(x);
+ exponent = (int) ((inbits >> 52) & 0x7ff) - 1023;
+ }
+
+ if (exponent == 1024) {
+ // Nan or infinity. Don't care which.
+ return x;
+ }
+
+ /* Divide the exponent by 3 */
+ int exp3 = exponent / 3;
+
+ /* p2 will be the nearest power of 2 to x with its exponent divided by 3 */
+ double p2 = Double.longBitsToDouble((inbits & 0x8000000000000000L) |
+ (long)(((exp3 + 1023) & 0x7ff)) << 52);
+
+ /* This will be a number between 1 and 2 */
+ final double mant = Double.longBitsToDouble((inbits & 0x000fffffffffffffL) | 0x3ff0000000000000L);
+
+ /* Estimate the cube root of mant by polynomial */
+ double est = -0.010714690733195933;
+ est = est * mant + 0.0875862700108075;
+ est = est * mant + -0.3058015757857271;
+ est = est * mant + 0.7249995199969751;
+ est = est * mant + 0.5039018405998233;
+
+ est *= CBRTTWO[exponent % 3 + 2];
+
+ // est should now be good to about 15 bits of precision. Do 2 rounds of
+ // Newton's method to get closer, this should get us full double precision
+ // Scale down x for the purpose of doing newtons method. This avoids over/under flows.
+ final double xs = x / (p2*p2*p2);
+ est += (xs - est*est*est) / (3*est*est);
+ est += (xs - est*est*est) / (3*est*est);
+
+ // Do one round of Newton's method in extended precision to get the last bit right.
+ double temp = est * HEX_40000000;
+ double ya = est + temp - temp;
+ double yb = est - ya;
+
+ double za = ya * ya;
+ double zb = ya * yb * 2.0 + yb * yb;
+ temp = za * HEX_40000000;
+ double temp2 = za + temp - temp;
+ zb += za - temp2;
+ za = temp2;
+
+ zb = za * yb + ya * zb + zb * yb;
+ za *= ya;
+
+ double na = xs - za;
+ double nb = -(na - xs + za);
+ nb -= zb;
+
+ est += (na+nb)/(3*est*est);
+
+ /* Scale by a power of two, so this is exact. */
+ est *= p2;
+
+ if (subnormal) {
+ est *= 3.814697265625E-6; // 2^-18
+ }
+
+ return est;
+ }
+
+ /**
+ * Convert degrees to radians, with error of less than 0.5 ULP
+ * @param x angle in degrees
+ * @return x converted into radians
+ */
+ public static double toRadians(double x)
+ {
+ if (Double.isInfinite(x) || x == 0.0) { // Matches +/- 0.0; return correct sign
+ return x;
+ }
+
+ // These are PI/180 split into high and low order bits
+ final double facta = 0.01745329052209854;
+ final double factb = 1.997844754509471E-9;
+
+ double xa = doubleHighPart(x);
+ double xb = x - xa;
+
+ double result = xb * factb + xb * facta + xa * factb + xa * facta;
+ if (result == 0) {
+ result *= x; // ensure correct sign if calculation underflows
+ }
+ return result;
+ }
+
+ /**
+ * Convert radians to degrees, with error of less than 0.5 ULP
+ * @param x angle in radians
+ * @return x converted into degrees
+ */
+ public static double toDegrees(double x)
+ {
+ if (Double.isInfinite(x) || x == 0.0) { // Matches +/- 0.0; return correct sign
+ return x;
+ }
+
+ // These are 180/PI split into high and low order bits
+ final double facta = 57.2957763671875;
+ final double factb = 3.145894820876798E-6;
+
+ double xa = doubleHighPart(x);
+ double xb = x - xa;
+
+ return xb * factb + xb * facta + xa * factb + xa * facta;
+ }
+
+ /**
+ * Absolute value.
+ * @param x number from which absolute value is requested
+ * @return abs(x)
+ */
+ public static int abs(final int x) {
+ final int i = x >>> 31;
+ return (x ^ (~i + 1)) + i;
+ }
+
+ /**
+ * Absolute value.
+ * @param x number from which absolute value is requested
+ * @return abs(x)
+ */
+ public static long abs(final long x) {
+ final long l = x >>> 63;
+ // l is one if x negative zero else
+ // ~l+1 is zero if x is positive, -1 if x is negative
+ // x^(~l+1) is x is x is positive, ~x if x is negative
+ // add around
+ return (x ^ (~l + 1)) + l;
+ }
+
+ /**
+ * Absolute value.
+ * @param x number from which absolute value is requested
+ * @return abs(x)
+ */
+ public static float abs(final float x) {
+ return Float.intBitsToFloat(MASK_NON_SIGN_INT & Float.floatToRawIntBits(x));
+ }
+
+ /**
+ * Absolute value.
+ * @param x number from which absolute value is requested
+ * @return abs(x)
+ */
+ public static double abs(double x) {
+ return Double.longBitsToDouble(MASK_NON_SIGN_LONG & Double.doubleToRawLongBits(x));
+ }
+
+ /**
+ * Compute least significant bit (Unit in Last Position) for a number.
+ * @param x number from which ulp is requested
+ * @return ulp(x)
+ */
+ public static double ulp(double x) {
+ if (Double.isInfinite(x)) {
+ return Double.POSITIVE_INFINITY;
+ }
+ return abs(x - Double.longBitsToDouble(Double.doubleToRawLongBits(x) ^ 1));
+ }
+
+ /**
+ * Compute least significant bit (Unit in Last Position) for a number.
+ * @param x number from which ulp is requested
+ * @return ulp(x)
+ */
+ public static float ulp(float x) {
+ if (Float.isInfinite(x)) {
+ return Float.POSITIVE_INFINITY;
+ }
+ return abs(x - Float.intBitsToFloat(Float.floatToIntBits(x) ^ 1));
+ }
+
+ /**
+ * Multiply a double number by a power of 2.
+ * @param d number to multiply
+ * @param n power of 2
+ * @return d × 2n
+ */
+ public static double scalb(final double d, final int n) {
+
+ // first simple and fast handling when 2^n can be represented using normal numbers
+ if ((n > -1023) && (n < 1024)) {
+ return d * Double.longBitsToDouble(((long) (n + 1023)) << 52);
+ }
+
+ // handle special cases
+ if (Double.isNaN(d) || Double.isInfinite(d) || (d == 0)) {
+ return d;
+ }
+ if (n < -2098) {
+ return (d > 0) ? 0.0 : -0.0;
+ }
+ if (n > 2097) {
+ return (d > 0) ? Double.POSITIVE_INFINITY : Double.NEGATIVE_INFINITY;
+ }
+
+ // decompose d
+ final long bits = Double.doubleToRawLongBits(d);
+ final long sign = bits & 0x8000000000000000L;
+ int exponent = ((int) (bits >>> 52)) & 0x7ff;
+ long mantissa = bits & 0x000fffffffffffffL;
+
+ // compute scaled exponent
+ int scaledExponent = exponent + n;
+
+ if (n < 0) {
+ // we are really in the case n <= -1023
+ if (scaledExponent > 0) {
+ // both the input and the result are normal numbers, we only adjust the exponent
+ return Double.longBitsToDouble(sign | (((long) scaledExponent) << 52) | mantissa);
+ } else if (scaledExponent > -53) {
+ // the input is a normal number and the result is a subnormal number
+
+ // recover the hidden mantissa bit
+ mantissa |= 1L << 52;
+
+ // scales down complete mantissa, hence losing least significant bits
+ final long mostSignificantLostBit = mantissa & (1L << (-scaledExponent));
+ mantissa >>>= 1 - scaledExponent;
+ if (mostSignificantLostBit != 0) {
+ // we need to add 1 bit to round up the result
+ mantissa++;
+ }
+ return Double.longBitsToDouble(sign | mantissa);
+
+ } else {
+ // no need to compute the mantissa, the number scales down to 0
+ return (sign == 0L) ? 0.0 : -0.0;
+ }
+ } else {
+ // we are really in the case n >= 1024
+ if (exponent == 0) {
+
+ // the input number is subnormal, normalize it
+ while ((mantissa >>> 52) != 1) {
+ mantissa <<= 1;
+ --scaledExponent;
+ }
+ ++scaledExponent;
+ mantissa &= 0x000fffffffffffffL;
+
+ if (scaledExponent < 2047) {
+ return Double.longBitsToDouble(sign | (((long) scaledExponent) << 52) | mantissa);
+ } else {
+ return (sign == 0L) ? Double.POSITIVE_INFINITY : Double.NEGATIVE_INFINITY;
+ }
+
+ } else if (scaledExponent < 2047) {
+ return Double.longBitsToDouble(sign | (((long) scaledExponent) << 52) | mantissa);
+ } else {
+ return (sign == 0L) ? Double.POSITIVE_INFINITY : Double.NEGATIVE_INFINITY;
+ }
+ }
+
+ }
+
+ /**
+ * Multiply a float number by a power of 2.
+ * @param f number to multiply
+ * @param n power of 2
+ * @return f × 2n
+ */
+ public static float scalb(final float f, final int n) {
+
+ // first simple and fast handling when 2^n can be represented using normal numbers
+ if ((n > -127) && (n < 128)) {
+ return f * Float.intBitsToFloat((n + 127) << 23);
+ }
+
+ // handle special cases
+ if (Float.isNaN(f) || Float.isInfinite(f) || (f == 0f)) {
+ return f;
+ }
+ if (n < -277) {
+ return (f > 0) ? 0.0f : -0.0f;
+ }
+ if (n > 276) {
+ return (f > 0) ? Float.POSITIVE_INFINITY : Float.NEGATIVE_INFINITY;
+ }
+
+ // decompose f
+ final int bits = Float.floatToIntBits(f);
+ final int sign = bits & 0x80000000;
+ int exponent = (bits >>> 23) & 0xff;
+ int mantissa = bits & 0x007fffff;
+
+ // compute scaled exponent
+ int scaledExponent = exponent + n;
+
+ if (n < 0) {
+ // we are really in the case n <= -127
+ if (scaledExponent > 0) {
+ // both the input and the result are normal numbers, we only adjust the exponent
+ return Float.intBitsToFloat(sign | (scaledExponent << 23) | mantissa);
+ } else if (scaledExponent > -24) {
+ // the input is a normal number and the result is a subnormal number
+
+ // recover the hidden mantissa bit
+ mantissa |= 1 << 23;
+
+ // scales down complete mantissa, hence losing least significant bits
+ final int mostSignificantLostBit = mantissa & (1 << (-scaledExponent));
+ mantissa >>>= 1 - scaledExponent;
+ if (mostSignificantLostBit != 0) {
+ // we need to add 1 bit to round up the result
+ mantissa++;
+ }
+ return Float.intBitsToFloat(sign | mantissa);
+
+ } else {
+ // no need to compute the mantissa, the number scales down to 0
+ return (sign == 0) ? 0.0f : -0.0f;
+ }
+ } else {
+ // we are really in the case n >= 128
+ if (exponent == 0) {
+
+ // the input number is subnormal, normalize it
+ while ((mantissa >>> 23) != 1) {
+ mantissa <<= 1;
+ --scaledExponent;
+ }
+ ++scaledExponent;
+ mantissa &= 0x007fffff;
+
+ if (scaledExponent < 255) {
+ return Float.intBitsToFloat(sign | (scaledExponent << 23) | mantissa);
+ } else {
+ return (sign == 0) ? Float.POSITIVE_INFINITY : Float.NEGATIVE_INFINITY;
+ }
+
+ } else if (scaledExponent < 255) {
+ return Float.intBitsToFloat(sign | (scaledExponent << 23) | mantissa);
+ } else {
+ return (sign == 0) ? Float.POSITIVE_INFINITY : Float.NEGATIVE_INFINITY;
+ }
+ }
+
+ }
+
+ /**
+ * Get the next machine representable number after a number, moving
+ * in the direction of another number.
+ *
+ * The ordering is as follows (increasing): + *
+ * If arguments compare equal, then the second argument is returned. + *
+ * If {@code direction} is greater than {@code d}, + * the smallest machine representable number strictly greater than + * {@code d} is returned; if less, then the largest representable number + * strictly less than {@code d} is returned.
+ *+ * If {@code d} is infinite and direction does not + * bring it back to finite numbers, it is returned unchanged.
+ * + * @param d base number + * @param direction (the only important thing is whether + * {@code direction} is greater or smaller than {@code d}) + * @return the next machine representable number in the specified direction + */ + public static double nextAfter(double d, double direction) { + + // handling of some important special cases + if (Double.isNaN(d) || Double.isNaN(direction)) { + return Double.NaN; + } else if (d == direction) { + return direction; + } else if (Double.isInfinite(d)) { + return (d < 0) ? -Double.MAX_VALUE : Double.MAX_VALUE; + } else if (d == 0) { + return (direction < 0) ? -Double.MIN_VALUE : Double.MIN_VALUE; + } + // special cases MAX_VALUE to infinity and MIN_VALUE to 0 + // are handled just as normal numbers + // can use raw bits since already dealt with infinity and NaN + final long bits = Double.doubleToRawLongBits(d); + final long sign = bits & 0x8000000000000000L; + if ((direction < d) ^ (sign == 0L)) { + return Double.longBitsToDouble(sign | ((bits & 0x7fffffffffffffffL) + 1)); + } else { + return Double.longBitsToDouble(sign | ((bits & 0x7fffffffffffffffL) - 1)); + } + + } + + /** + * Get the next machine representable number after a number, moving + * in the direction of another number. + *+ * The ordering is as follows (increasing): + *
+ * If arguments compare equal, then the second argument is returned. + *
+ * If {@code direction} is greater than {@code f}, + * the smallest machine representable number strictly greater than + * {@code f} is returned; if less, then the largest representable number + * strictly less than {@code f} is returned.
+ *+ * If {@code f} is infinite and direction does not + * bring it back to finite numbers, it is returned unchanged.
+ * + * @param f base number + * @param direction (the only important thing is whether + * {@code direction} is greater or smaller than {@code f}) + * @return the next machine representable number in the specified direction + */ + public static float nextAfter(final float f, final double direction) { + + // handling of some important special cases + if (Double.isNaN(f) || Double.isNaN(direction)) { + return Float.NaN; + } else if (f == direction) { + return (float) direction; + } else if (Float.isInfinite(f)) { + return (f < 0f) ? -Float.MAX_VALUE : Float.MAX_VALUE; + } else if (f == 0f) { + return (direction < 0) ? -Float.MIN_VALUE : Float.MIN_VALUE; + } + // special cases MAX_VALUE to infinity and MIN_VALUE to 0 + // are handled just as normal numbers + + final int bits = Float.floatToIntBits(f); + final int sign = bits & 0x80000000; + if ((direction < f) ^ (sign == 0)) { + return Float.intBitsToFloat(sign | ((bits & 0x7fffffff) + 1)); + } else { + return Float.intBitsToFloat(sign | ((bits & 0x7fffffff) - 1)); + } + + } + + /** Get the largest whole number smaller than x. + * @param x number from which floor is requested + * @return a double number f such that f is an integer f <= x < f + 1.0 + */ + public static double floor(double x) { + long y; + + if (Double.isNaN(x)) { + return x; + } + + if (x >= TWO_POWER_52 || x <= -TWO_POWER_52) { + return x; + } + + y = (long) x; + if (x < 0 && y != x) { + y--; + } + + if (y == 0) { + return x*y; + } + + return y; + } + + /** Get the smallest whole number larger than x. + * @param x number from which ceil is requested + * @return a double number c such that c is an integer c - 1.0 < x <= c + */ + public static double ceil(double x) { + double y; + + if (Double.isNaN(x)) { + return x; + } + + y = floor(x); + if (y == x) { + return y; + } + + y += 1.0; + + if (y == 0) { + return x*y; + } + + return y; + } + + /** Get the whole number that is the nearest to x, or the even one if x is exactly half way between two integers. + * @param x number from which nearest whole number is requested + * @return a double number r such that r is an integer r - 0.5 <= x <= r + 0.5 + */ + public static double rint(double x) { + double y = floor(x); + double d = x - y; + + if (d > 0.5) { + if (y == -1.0) { + return -0.0; // Preserve sign of operand + } + return y+1.0; + } + if (d < 0.5) { + return y; + } + + /* half way, round to even */ + long z = (long) y; + return (z & 1) == 0 ? y : y + 1.0; + } + + /** Get the closest long to x. + * @param x number from which closest long is requested + * @return closest long to x + */ + public static long round(double x) { + final long bits = Double.doubleToRawLongBits(x); + final int biasedExp = ((int)(bits>>52)) & 0x7ff; + // Shift to get rid of bits past comma except first one: will need to + // 1-shift to the right to end up with correct magnitude. + final int shift = (52 - 1 + Double.MAX_EXPONENT) - biasedExp; + if ((shift & -64) == 0) { + // shift in [0,63], so unbiased exp in [-12,51]. + long extendedMantissa = 0x0010000000000000L | (bits & 0x000fffffffffffffL); + if (bits < 0) { + extendedMantissa = -extendedMantissa; + } + // If value is positive and first bit past comma is 0, rounding + // to lower integer, else to upper one, which is what "+1" and + // then ">>1" do. + return ((extendedMantissa >> shift) + 1L) >> 1; + } else { + // +-Infinity, NaN, or a mathematical integer. + return (long) x; + } + } + + /** Get the closest int to x. + * @param x number from which closest int is requested + * @return closest int to x + */ + public static int round(final float x) { + final int bits = Float.floatToRawIntBits(x); + final int biasedExp = (bits>>23) & 0xff; + // Shift to get rid of bits past comma except first one: will need to + // 1-shift to the right to end up with correct magnitude. + final int shift = (23 - 1 + Float.MAX_EXPONENT) - biasedExp; + if ((shift & -32) == 0) { + // shift in [0,31], so unbiased exp in [-9,22]. + int extendedMantissa = 0x00800000 | (bits & 0x007fffff); + if (bits < 0) { + extendedMantissa = -extendedMantissa; + } + // If value is positive and first bit past comma is 0, rounding + // to lower integer, else to upper one, which is what "+1" and + // then ">>1" do. + return ((extendedMantissa >> shift) + 1) >> 1; + } else { + // +-Infinity, NaN, or a mathematical integer. + return (int) x; + } + } + + /** Compute the minimum of two values + * @param a first value + * @param b second value + * @return a if a is lesser or equal to b, b otherwise + */ + public static int min(final int a, final int b) { + return (a <= b) ? a : b; + } + + /** Compute the minimum of two values + * @param a first value + * @param b second value + * @return a if a is lesser or equal to b, b otherwise + */ + public static long min(final long a, final long b) { + return (a <= b) ? a : b; + } + + /** Compute the minimum of two values + * @param a first value + * @param b second value + * @return a if a is lesser or equal to b, b otherwise + */ + public static float min(final float a, final float b) { + if (a > b) { + return b; + } + if (a < b) { + return a; + } + /* if either arg is NaN, return NaN */ + if (a != b) { + return Float.NaN; + } + /* min(+0.0,-0.0) == -0.0 */ + /* 0x80000000 == Float.floatToRawIntBits(-0.0d) */ + int bits = Float.floatToRawIntBits(a); + if (bits == 0x80000000) { + return a; + } + return b; + } + + /** Compute the minimum of two values + * @param a first value + * @param b second value + * @return a if a is lesser or equal to b, b otherwise + */ + public static double min(final double a, final double b) { + if (a > b) { + return b; + } + if (a < b) { + return a; + } + /* if either arg is NaN, return NaN */ + if (a != b) { + return Double.NaN; + } + /* min(+0.0,-0.0) == -0.0 */ + /* 0x8000000000000000L == Double.doubleToRawLongBits(-0.0d) */ + long bits = Double.doubleToRawLongBits(a); + if (bits == 0x8000000000000000L) { + return a; + } + return b; + } + + /** Compute the maximum of two values + * @param a first value + * @param b second value + * @return b if a is lesser or equal to b, a otherwise + */ + public static int max(final int a, final int b) { + return (a <= b) ? b : a; + } + + /** Compute the maximum of two values + * @param a first value + * @param b second value + * @return b if a is lesser or equal to b, a otherwise + */ + public static long max(final long a, final long b) { + return (a <= b) ? b : a; + } + + /** Compute the maximum of two values + * @param a first value + * @param b second value + * @return b if a is lesser or equal to b, a otherwise + */ + public static float max(final float a, final float b) { + if (a > b) { + return a; + } + if (a < b) { + return b; + } + /* if either arg is NaN, return NaN */ + if (a != b) { + return Float.NaN; + } + /* min(+0.0,-0.0) == -0.0 */ + /* 0x80000000 == Float.floatToRawIntBits(-0.0d) */ + int bits = Float.floatToRawIntBits(a); + if (bits == 0x80000000) { + return b; + } + return a; + } + + /** Compute the maximum of two values + * @param a first value + * @param b second value + * @return b if a is lesser or equal to b, a otherwise + */ + public static double max(final double a, final double b) { + if (a > b) { + return a; + } + if (a < b) { + return b; + } + /* if either arg is NaN, return NaN */ + if (a != b) { + return Double.NaN; + } + /* min(+0.0,-0.0) == -0.0 */ + /* 0x8000000000000000L == Double.doubleToRawLongBits(-0.0d) */ + long bits = Double.doubleToRawLongBits(a); + if (bits == 0x8000000000000000L) { + return b; + } + return a; + } + + /** + * Returns the hypotenuse of a triangle with sides {@code x} and {@code y} + * - sqrt(x2 +y2)+ * This methods returns the same value as integer division when + * a and b are same signs, but returns a different value when + * they are opposite (i.e. q is negative). + *
+ * @param a dividend + * @param b divisor + * @return q such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0 + * @exception MathArithmeticException if b == 0 + * @see #floorMod(int, int) + * @since 3.4 + */ + public static int floorDiv(final int a, final int b) throws MathArithmeticException { + + if (b == 0) { + throw new MathArithmeticException(LocalizedFormats.ZERO_DENOMINATOR); + } + + final int m = a % b; + if ((a ^ b) >= 0 || m == 0) { + // a an b have same sign, or division is exact + return a / b; + } else { + // a and b have opposite signs and division is not exact + return (a / b) - 1; + } + + } + + /** Finds q such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0. + *+ * This methods returns the same value as integer division when + * a and b are same signs, but returns a different value when + * they are opposite (i.e. q is negative). + *
+ * @param a dividend + * @param b divisor + * @return q such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0 + * @exception MathArithmeticException if b == 0 + * @see #floorMod(long, long) + * @since 3.4 + */ + public static long floorDiv(final long a, final long b) throws MathArithmeticException { + + if (b == 0l) { + throw new MathArithmeticException(LocalizedFormats.ZERO_DENOMINATOR); + } + + final long m = a % b; + if ((a ^ b) >= 0l || m == 0l) { + // a an b have same sign, or division is exact + return a / b; + } else { + // a and b have opposite signs and division is not exact + return (a / b) - 1l; + } + + } + + /** Finds r such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0. + *+ * This methods returns the same value as integer modulo when + * a and b are same signs, but returns a different value when + * they are opposite (i.e. q is negative). + *
+ * @param a dividend + * @param b divisor + * @return r such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0 + * @exception MathArithmeticException if b == 0 + * @see #floorDiv(int, int) + * @since 3.4 + */ + public static int floorMod(final int a, final int b) throws MathArithmeticException { + + if (b == 0) { + throw new MathArithmeticException(LocalizedFormats.ZERO_DENOMINATOR); + } + + final int m = a % b; + if ((a ^ b) >= 0 || m == 0) { + // a an b have same sign, or division is exact + return m; + } else { + // a and b have opposite signs and division is not exact + return b + m; + } + + } + + /** Finds r such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0. + *+ * This methods returns the same value as integer modulo when + * a and b are same signs, but returns a different value when + * they are opposite (i.e. q is negative). + *
+ * @param a dividend + * @param b divisor + * @return r such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0 + * @exception MathArithmeticException if b == 0 + * @see #floorDiv(long, long) + * @since 3.4 + */ + public static long floorMod(final long a, final long b) { + + if (b == 0l) { + throw new MathArithmeticException(LocalizedFormats.ZERO_DENOMINATOR); + } + + final long m = a % b; + if ((a ^ b) >= 0l || m == 0l) { + // a an b have same sign, or division is exact + return m; + } else { + // a and b have opposite signs and division is not exact + return b + m; + } + + } + + /** + * Returns the first argument with the sign of the second argument. + * A NaN {@code sign} argument is treated as positive. + * + * @param magnitude the value to return + * @param sign the sign for the returned value + * @return the magnitude with the same sign as the {@code sign} argument + */ + public static double copySign(double magnitude, double sign){ + // The highest order bit is going to be zero if the + // highest order bit of m and s is the same and one otherwise. + // So (m^s) will be positive if both m and s have the same sign + // and negative otherwise. + final long m = Double.doubleToRawLongBits(magnitude); // don't care about NaN + final long s = Double.doubleToRawLongBits(sign); + if ((m^s) >= 0) { + return magnitude; + } + return -magnitude; // flip sign + } + + /** + * Returns the first argument with the sign of the second argument. + * A NaN {@code sign} argument is treated as positive. + * + * @param magnitude the value to return + * @param sign the sign for the returned value + * @return the magnitude with the same sign as the {@code sign} argument + */ + public static float copySign(float magnitude, float sign){ + // The highest order bit is going to be zero if the + // highest order bit of m and s is the same and one otherwise. + // So (m^s) will be positive if both m and s have the same sign + // and negative otherwise. + final int m = Float.floatToRawIntBits(magnitude); + final int s = Float.floatToRawIntBits(sign); + if ((m^s) >= 0) { + return magnitude; + } + return -magnitude; // flip sign + } + + /** + * Return the exponent of a double number, removing the bias. + *+ * For double numbers of the form 2x, the unbiased + * exponent is exactly x. + *
+ * @param d number from which exponent is requested + * @return exponent for d in IEEE754 representation, without bias + */ + public static int getExponent(final double d) { + // NaN and Infinite will return 1024 anywho so can use raw bits + return (int) ((Double.doubleToRawLongBits(d) >>> 52) & 0x7ff) - 1023; + } + + /** + * Return the exponent of a float number, removing the bias. + *+ * For float numbers of the form 2x, the unbiased + * exponent is exactly x. + *
+ * @param f number from which exponent is requested + * @return exponent for d in IEEE754 representation, without bias + */ + public static int getExponent(final float f) { + // NaN and Infinite will return the same exponent anywho so can use raw bits + return ((Float.floatToRawIntBits(f) >>> 23) & 0xff) - 127; + } + + /** + * Print out contents of arrays, and check the length. + *used to generate the preset arrays originally.
+ * @param a unused + */ + public static void main(String[] a) { + PrintStream out = System.out; + AccurateMathCalc.printarray(out, "EXP_INT_TABLE_A", EXP_INT_TABLE_LEN, ExpIntTable.EXP_INT_TABLE_A); + AccurateMathCalc.printarray(out, "EXP_INT_TABLE_B", EXP_INT_TABLE_LEN, ExpIntTable.EXP_INT_TABLE_B); + AccurateMathCalc.printarray(out, "EXP_FRAC_TABLE_A", EXP_FRAC_TABLE_LEN, ExpFracTable.EXP_FRAC_TABLE_A); + AccurateMathCalc.printarray(out, "EXP_FRAC_TABLE_B", EXP_FRAC_TABLE_LEN, ExpFracTable.EXP_FRAC_TABLE_B); + AccurateMathCalc.printarray(out, "LN_MANT",LN_MANT_LEN, lnMant.LN_MANT); + AccurateMathCalc.printarray(out, "SINE_TABLE_A", SINE_TABLE_LEN, SINE_TABLE_A); + AccurateMathCalc.printarray(out, "SINE_TABLE_B", SINE_TABLE_LEN, SINE_TABLE_B); + AccurateMathCalc.printarray(out, "COSINE_TABLE_A", SINE_TABLE_LEN, COSINE_TABLE_A); + AccurateMathCalc.printarray(out, "COSINE_TABLE_B", SINE_TABLE_LEN, COSINE_TABLE_B); + AccurateMathCalc.printarray(out, "TANGENT_TABLE_A", SINE_TABLE_LEN, TANGENT_TABLE_A); + AccurateMathCalc.printarray(out, "TANGENT_TABLE_B", SINE_TABLE_LEN, TANGENT_TABLE_B); + } + + /** Enclose large data table in nested static class so it's only loaded on first access. */ + private static class ExpIntTable { + /** Exponential evaluated at integer values, + * exp(x) = expIntTableA[x + EXP_INT_TABLE_MAX_INDEX] + expIntTableB[x+EXP_INT_TABLE_MAX_INDEX]. + */ + private static final double[] EXP_INT_TABLE_A; + /** Exponential evaluated at integer values, + * exp(x) = expIntTableA[x + EXP_INT_TABLE_MAX_INDEX] + expIntTableB[x+EXP_INT_TABLE_MAX_INDEX] + */ + private static final double[] EXP_INT_TABLE_B; + + static { + if (RECOMPUTE_TABLES_AT_RUNTIME) { + EXP_INT_TABLE_A = new double[AccurateMath.EXP_INT_TABLE_LEN]; + EXP_INT_TABLE_B = new double[AccurateMath.EXP_INT_TABLE_LEN]; + + final double tmp[] = new double[2]; + final double recip[] = new double[2]; + + // Populate expIntTable + for (int i = 0; i < AccurateMath.EXP_INT_TABLE_MAX_INDEX; i++) { + AccurateMathCalc.expint(i, tmp); + EXP_INT_TABLE_A[i + AccurateMath.EXP_INT_TABLE_MAX_INDEX] = tmp[0]; + EXP_INT_TABLE_B[i + AccurateMath.EXP_INT_TABLE_MAX_INDEX] = tmp[1]; + + if (i != 0) { + // Negative integer powers + AccurateMathCalc.splitReciprocal(tmp, recip); + EXP_INT_TABLE_A[AccurateMath.EXP_INT_TABLE_MAX_INDEX - i] = recip[0]; + EXP_INT_TABLE_B[AccurateMath.EXP_INT_TABLE_MAX_INDEX - i] = recip[1]; + } + } + } else { + EXP_INT_TABLE_A = AccurateMathLiteralArrays.loadExpIntA(); + EXP_INT_TABLE_B = AccurateMathLiteralArrays.loadExpIntB(); + } + } + } + + /** Enclose large data table in nested static class so it's only loaded on first access. */ + private static class ExpFracTable { + /** Exponential over the range of 0 - 1 in increments of 2^-10 + * exp(x/1024) = expFracTableA[x] + expFracTableB[x]. + * 1024 = 2^10 + */ + private static final double[] EXP_FRAC_TABLE_A; + /** Exponential over the range of 0 - 1 in increments of 2^-10 + * exp(x/1024) = expFracTableA[x] + expFracTableB[x]. + */ + private static final double[] EXP_FRAC_TABLE_B; + + static { + if (RECOMPUTE_TABLES_AT_RUNTIME) { + EXP_FRAC_TABLE_A = new double[AccurateMath.EXP_FRAC_TABLE_LEN]; + EXP_FRAC_TABLE_B = new double[AccurateMath.EXP_FRAC_TABLE_LEN]; + + final double tmp[] = new double[2]; + + // Populate expFracTable + final double factor = 1d / (EXP_FRAC_TABLE_LEN - 1); + for (int i = 0; i < EXP_FRAC_TABLE_A.length; i++) { + AccurateMathCalc.slowexp(i * factor, tmp); + EXP_FRAC_TABLE_A[i] = tmp[0]; + EXP_FRAC_TABLE_B[i] = tmp[1]; + } + } else { + EXP_FRAC_TABLE_A = AccurateMathLiteralArrays.loadExpFracA(); + EXP_FRAC_TABLE_B = AccurateMathLiteralArrays.loadExpFracB(); + } + } + } + + /** Enclose large data table in nested static class so it's only loaded on first access. */ + private static class lnMant { + /** Extended precision logarithm table over the range 1 - 2 in increments of 2^-10. */ + private static final double[][] LN_MANT; + + static { + if (RECOMPUTE_TABLES_AT_RUNTIME) { + LN_MANT = new double[AccurateMath.LN_MANT_LEN][]; + + // Populate lnMant table + for (int i = 0; i < LN_MANT.length; i++) { + final double d = Double.longBitsToDouble( (((long) i) << 42) | 0x3ff0000000000000L ); + LN_MANT[i] = AccurateMathCalc.slowLog(d); + } + } else { + LN_MANT = AccurateMathLiteralArrays.loadLnMant(); + } + } + } + + /** Enclose the Cody/Waite reduction (used in "sin", "cos" and "tan"). */ + private static class CodyWaite { + /** k */ + private final int finalK; + /** remA */ + private final double finalRemA; + /** remB */ + private final double finalRemB; + + /** + * @param xa Argument. + */ + CodyWaite(double xa) { + // Estimate k. + //k = (int)(xa / 1.5707963267948966); + int k = (int)(xa * 0.6366197723675814); + + // Compute remainder. + double remA; + double remB; + while (true) { + double a = -k * 1.570796251296997; + remA = xa + a; + remB = -(remA - xa - a); + + a = -k * 7.549789948768648E-8; + double b = remA; + remA = a + b; + remB += -(remA - b - a); + + a = -k * 6.123233995736766E-17; + b = remA; + remA = a + b; + remB += -(remA - b - a); + + if (remA > 0) { + break; + } + + // Remainder is negative, so decrement k and try again. + // This should only happen if the input is very close + // to an even multiple of pi/2. + --k; + } + + this.finalK = k; + this.finalRemA = remA; + this.finalRemB = remB; + } + + /** + * @return k + */ + int getK() { + return finalK; + } + /** + * @return remA + */ + double getRemA() { + return finalRemA; + } + /** + * @return remB + */ + double getRemB() { + return finalRemB; + } + } +} diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/util/FastMath.java b/commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMath.java.bak similarity index 97% rename from commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/util/FastMath.java rename to commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMath.java.bak index 07175f4cf..7a39abcde 100644 --- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/util/FastMath.java +++ b/commons-math-legacy-core/src/main/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMath.java.bak @@ -25,36 +25,36 @@ import org.apache.commons.math4.legacy.exception.util.LocalizedFormats; /** * Portable alternative to {@link Math} and {@link StrictMath}. *- * Caveat: At the time of implementation, the {@code FastMath} functions + * Caveat: At the time of implementation, the {@code AccurateMath} functions * were often faster and/or more accurate than their JDK equivalent. * Nowadays, it would not be surprising that they are always slower (due * to the various JVM optimizations that have appeared since Java 5). * However, any change to this class should ensure that the current * accuracy is not lost. *
- * FastMath is a drop-in replacement for both Math and StrictMath. This + * AccurateMath is a drop-in replacement for both Math and StrictMath. This * means that for any method in Math (say {@code Math.sin(x)} or * {@code Math.cbrt(y)}), user can directly change the class and use the - * methods as is (using {@code FastMath.sin(x)} or {@code FastMath.cbrt(y)} + * methods as is (using {@code AccurateMath.sin(x)} or {@code AccurateMath.cbrt(y)} * in the previous example). *
*- * FastMath speed is achieved by relying heavily on optimizing compilers + * AccurateMath speed is achieved by relying heavily on optimizing compilers * to native code present in many JVMs today and use of large tables. * The larger tables are lazily initialized on first use, so that the setup * time does not penalize methods that don't need them. *
*- * Note that FastMath is + * Note that AccurateMath is * extensively used inside Apache Commons Math, so by calling some algorithms, * the overhead when the tables need to be initialized will occur - * regardless of the end-user calling FastMath methods directly or not. + * regardless of the end-user calling AccurateMath methods directly or not. * Performance figures for a specific JVM and hardware can be evaluated by - * running the FastMathTestPerformance tests in the test directory of the source + * running the AccurateMathTestPerformance tests in the test directory of the source * distribution. *
*- * FastMath accuracy should be mostly independent of the JVM as it relies only + * AccurateMath accuracy should be mostly independent of the JVM as it relies only * on IEEE-754 basic operations and on embedded tables. Almost all operations * are accurate to about 0.5 ulp throughout the domain range. This statement, * of course is only a rough global observed behavior, it is not a @@ -63,14 +63,14 @@ import org.apache.commons.math4.legacy.exception.util.LocalizedFormats; * Maker's Dilemma). *
*- * FastMath additionally implements the following methods not found in Math/StrictMath: + * AccurateMath additionally implements the following methods not found in Math/StrictMath: *
+ * Running all tests independently:
* Running all tests independently: This class implements the computation rules described in Dan Kalman's paper 0; --i) {
function[i] = xk;
xk *= operand[operandOffset];
@@ -946,8 +946,8 @@ public class DSCompiler {
if (n > 0) {
// strictly positive power
- final int maxOrder = FastMath.min(order, n);
- double xk = FastMath.pow(operand[operandOffset], n - maxOrder);
+ final int maxOrder = AccurateMath.min(order, n);
+ double xk = AccurateMath.pow(operand[operandOffset], n - maxOrder);
for (int i = maxOrder; i > 0; --i) {
function[i] = xk;
xk *= operand[operandOffset];
@@ -956,7 +956,7 @@ public class DSCompiler {
} else {
// strictly negative power
final double inv = 1.0 / operand[operandOffset];
- double xk = FastMath.pow(inv, -n);
+ double xk = AccurateMath.pow(inv, -n);
for (int i = 0; i <= order; ++i) {
function[i] = xk;
xk *= inv;
@@ -1011,14 +1011,14 @@ public class DSCompiler {
double[] function = new double[1 + order];
double xk;
if (n == 2) {
- function[0] = FastMath.sqrt(operand[operandOffset]);
+ function[0] = AccurateMath.sqrt(operand[operandOffset]);
xk = 0.5 / function[0];
} else if (n == 3) {
- function[0] = FastMath.cbrt(operand[operandOffset]);
+ function[0] = AccurateMath.cbrt(operand[operandOffset]);
xk = 1.0 / (3.0 * function[0] * function[0]);
} else {
- function[0] = FastMath.pow(operand[operandOffset], 1.0 / n);
- xk = 1.0 / (n * FastMath.pow(function[0], n - 1));
+ function[0] = AccurateMath.pow(operand[operandOffset], 1.0 / n);
+ xk = 1.0 / (n * AccurateMath.pow(function[0], n - 1));
}
final double nReciprocal = 1.0 / n;
final double xReciprocal = 1.0 / operand[operandOffset];
@@ -1045,7 +1045,7 @@ public class DSCompiler {
// create the function value and derivatives
double[] function = new double[1 + order];
- Arrays.fill(function, FastMath.exp(operand[operandOffset]));
+ Arrays.fill(function, AccurateMath.exp(operand[operandOffset]));
// apply function composition
compose(operand, operandOffset, function, result, resultOffset);
@@ -1065,8 +1065,8 @@ public class DSCompiler {
// create the function value and derivatives
double[] function = new double[1 + order];
- function[0] = FastMath.expm1(operand[operandOffset]);
- Arrays.fill(function, 1, 1 + order, FastMath.exp(operand[operandOffset]));
+ function[0] = AccurateMath.expm1(operand[operandOffset]);
+ Arrays.fill(function, 1, 1 + order, AccurateMath.exp(operand[operandOffset]));
// apply function composition
compose(operand, operandOffset, function, result, resultOffset);
@@ -1086,7 +1086,7 @@ public class DSCompiler {
// create the function value and derivatives
double[] function = new double[1 + order];
- function[0] = FastMath.log(operand[operandOffset]);
+ function[0] = AccurateMath.log(operand[operandOffset]);
if (order > 0) {
double inv = 1.0 / operand[operandOffset];
double xk = inv;
@@ -1113,7 +1113,7 @@ public class DSCompiler {
// create the function value and derivatives
double[] function = new double[1 + order];
- function[0] = FastMath.log1p(operand[operandOffset]);
+ function[0] = AccurateMath.log1p(operand[operandOffset]);
if (order > 0) {
double inv = 1.0 / (1.0 + operand[operandOffset]);
double xk = inv;
@@ -1140,10 +1140,10 @@ public class DSCompiler {
// create the function value and derivatives
double[] function = new double[1 + order];
- function[0] = FastMath.log10(operand[operandOffset]);
+ function[0] = AccurateMath.log10(operand[operandOffset]);
if (order > 0) {
double inv = 1.0 / operand[operandOffset];
- double xk = inv / FastMath.log(10.0);
+ double xk = inv / AccurateMath.log(10.0);
for (int i = 1; i <= order; ++i) {
function[i] = xk;
xk *= -i * inv;
@@ -1168,9 +1168,9 @@ public class DSCompiler {
// create the function value and derivatives
double[] function = new double[1 + order];
- function[0] = FastMath.cos(operand[operandOffset]);
+ function[0] = AccurateMath.cos(operand[operandOffset]);
if (order > 0) {
- function[1] = -FastMath.sin(operand[operandOffset]);
+ function[1] = -AccurateMath.sin(operand[operandOffset]);
for (int i = 2; i <= order; ++i) {
function[i] = -function[i - 2];
}
@@ -1194,9 +1194,9 @@ public class DSCompiler {
// create the function value and derivatives
double[] function = new double[1 + order];
- function[0] = FastMath.sin(operand[operandOffset]);
+ function[0] = AccurateMath.sin(operand[operandOffset]);
if (order > 0) {
- function[1] = FastMath.cos(operand[operandOffset]);
+ function[1] = AccurateMath.cos(operand[operandOffset]);
for (int i = 2; i <= order; ++i) {
function[i] = -function[i - 2];
}
@@ -1220,7 +1220,7 @@ public class DSCompiler {
// create the function value and derivatives
final double[] function = new double[1 + order];
- final double t = FastMath.tan(operand[operandOffset]);
+ final double t = AccurateMath.tan(operand[operandOffset]);
function[0] = t;
if (order > 0) {
@@ -1276,7 +1276,7 @@ public class DSCompiler {
// create the function value and derivatives
double[] function = new double[1 + order];
final double x = operand[operandOffset];
- function[0] = FastMath.acos(x);
+ function[0] = AccurateMath.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)
@@ -1289,7 +1289,7 @@ public class DSCompiler {
p[0] = -1;
final double x2 = x * x;
final double f = 1.0 / (1 - x2);
- double coeff = FastMath.sqrt(f);
+ double coeff = AccurateMath.sqrt(f);
function[1] = coeff * p[0];
for (int n = 2; n <= order; ++n) {
@@ -1333,7 +1333,7 @@ public class DSCompiler {
// create the function value and derivatives
double[] function = new double[1 + order];
final double x = operand[operandOffset];
- function[0] = FastMath.asin(x);
+ function[0] = AccurateMath.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)
@@ -1346,7 +1346,7 @@ public class DSCompiler {
p[0] = 1;
final double x2 = x * x;
final double f = 1.0 / (1 - x2);
- double coeff = FastMath.sqrt(f);
+ double coeff = AccurateMath.sqrt(f);
function[1] = coeff * p[0];
for (int n = 2; n <= order; ++n) {
@@ -1390,7 +1390,7 @@ public class DSCompiler {
// create the function value and derivatives
double[] function = new double[1 + order];
final double x = operand[operandOffset];
- function[0] = FastMath.atan(x);
+ function[0] = AccurateMath.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
@@ -1472,7 +1472,7 @@ public class DSCompiler {
divide(y, yOffset, tmp2, 0, tmp1, 0); // y /(r - x)
atan(tmp1, 0, tmp2, 0); // atan(y / (r - x))
result[resultOffset] =
- ((tmp2[0] <= 0) ? -FastMath.PI : FastMath.PI) - 2 * tmp2[0]; // +/-pi - 2 * atan(y / (r - x))
+ ((tmp2[0] <= 0) ? -AccurateMath.PI : AccurateMath.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))
}
@@ -1480,7 +1480,7 @@ public class DSCompiler {
}
// fix value to take special cases (+0/+0, +0/-0, -0/+0, -0/-0, +/-infinity) correctly
- result[resultOffset] = FastMath.atan2(y[yOffset], x[xOffset]);
+ result[resultOffset] = AccurateMath.atan2(y[yOffset], x[xOffset]);
}
@@ -1497,9 +1497,9 @@ public class DSCompiler {
// create the function value and derivatives
double[] function = new double[1 + order];
- function[0] = FastMath.cosh(operand[operandOffset]);
+ function[0] = AccurateMath.cosh(operand[operandOffset]);
if (order > 0) {
- function[1] = FastMath.sinh(operand[operandOffset]);
+ function[1] = AccurateMath.sinh(operand[operandOffset]);
for (int i = 2; i <= order; ++i) {
function[i] = function[i - 2];
}
@@ -1523,9 +1523,9 @@ public class DSCompiler {
// create the function value and derivatives
double[] function = new double[1 + order];
- function[0] = FastMath.sinh(operand[operandOffset]);
+ function[0] = AccurateMath.sinh(operand[operandOffset]);
if (order > 0) {
- function[1] = FastMath.cosh(operand[operandOffset]);
+ function[1] = AccurateMath.cosh(operand[operandOffset]);
for (int i = 2; i <= order; ++i) {
function[i] = function[i - 2];
}
@@ -1549,7 +1549,7 @@ public class DSCompiler {
// create the function value and derivatives
final double[] function = new double[1 + order];
- final double t = FastMath.tanh(operand[operandOffset]);
+ final double t = AccurateMath.tanh(operand[operandOffset]);
function[0] = t;
if (order > 0) {
@@ -1605,7 +1605,7 @@ public class DSCompiler {
// create the function value and derivatives
double[] function = new double[1 + order];
final double x = operand[operandOffset];
- function[0] = FastMath.acosh(x);
+ function[0] = AccurateMath.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)
@@ -1618,7 +1618,7 @@ public class DSCompiler {
p[0] = 1;
final double x2 = x * x;
final double f = 1.0 / (x2 - 1);
- double coeff = FastMath.sqrt(f);
+ double coeff = AccurateMath.sqrt(f);
function[1] = coeff * p[0];
for (int n = 2; n <= order; ++n) {
@@ -1662,7 +1662,7 @@ public class DSCompiler {
// create the function value and derivatives
double[] function = new double[1 + order];
final double x = operand[operandOffset];
- function[0] = FastMath.asinh(x);
+ function[0] = AccurateMath.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)
@@ -1675,7 +1675,7 @@ public class DSCompiler {
p[0] = 1;
final double x2 = x * x;
final double f = 1.0 / (1 + x2);
- double coeff = FastMath.sqrt(f);
+ double coeff = AccurateMath.sqrt(f);
function[1] = coeff * p[0];
for (int n = 2; n <= order; ++n) {
@@ -1719,7 +1719,7 @@ public class DSCompiler {
// create the function value and derivatives
double[] function = new double[1 + order];
final double x = operand[operandOffset];
- function[0] = FastMath.atanh(x);
+ function[0] = AccurateMath.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
@@ -1805,7 +1805,7 @@ public class DSCompiler {
for (int k = 0; k < orders.length; ++k) {
if (orders[k] > 0) {
try {
- term *= FastMath.pow(delta[k], orders[k]) / FACTORIAL.value(orders[k]);
+ term *= AccurateMath.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 db3d15202..36c13f638 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
@@ -20,14 +20,14 @@ import java.util.Arrays;
import java.io.Serializable;
import org.apache.commons.numbers.arrays.LinearCombination;
-import org.apache.commons.math4.legacy.Field;
-import org.apache.commons.math4.legacy.FieldElement;
-import org.apache.commons.math4.legacy.RealFieldElement;
+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.exception.DimensionMismatchException;
import org.apache.commons.math4.legacy.exception.MathArithmeticException;
import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
-import org.apache.commons.math4.legacy.util.FastMath;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.legacy.core.MathArrays;
/** Class representing both the value and the differentials of a function.
* This class is the workhorse of the differentiation package.
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 9134d0d21..525cc210a 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,8 +26,8 @@ import org.apache.commons.math4.legacy.exception.NotPositiveException;
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.util.FastMath;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Utility class for the {@link MicrosphereProjectionInterpolator} algorithm.
@@ -224,13 +224,13 @@ public class InterpolatingMicrosphere {
final double[] diff = MathArrays.ebeSubtract(samplePoints[i], point);
final double diffNorm = SafeNorm.value(diff);
- if (FastMath.abs(diffNorm) < noInterpolationTolerance) {
+ if (AccurateMath.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 = FastMath.pow(diffNorm, -exponent);
+ final double weight = AccurateMath.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 64af4fc3f..e0db5d634 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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
import org.apache.commons.numbers.angle.PlaneAngleRadians;
/**
@@ -60,8 +60,8 @@ public class InterpolatingMicrosphere2D extends InterpolatingMicrosphere {
for (int i = 0; i < size; i++) {
final double angle = i * PlaneAngleRadians.TWO_PI / size;
- add(new double[] { FastMath.cos(angle),
- FastMath.sin(angle) },
+ add(new double[] { AccurateMath.cos(angle),
+ AccurateMath.sin(angle) },
false);
}
}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/LinearInterpolator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/LinearInterpolator.java
index aece38885..a2679df4f 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/LinearInterpolator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/LinearInterpolator.java
@@ -22,7 +22,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.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Implements a linear function for interpolation of real univariate functions.
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 c56955c71..37557aaab 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,8 +28,8 @@ 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.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.util.FastMath;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Implements the
@@ -296,7 +296,7 @@ public class LoessInterpolator
double sumXSquared = 0;
double sumY = 0;
double sumXY = 0;
- double denom = FastMath.abs(1.0 / (xval[edge] - x));
+ double denom = AccurateMath.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 @@ public class LoessInterpolator
final double meanXSquared = sumXSquared / sumWeights;
final double beta;
- if (FastMath.sqrt(FastMath.abs(meanXSquared - meanX * meanX)) < accuracy) {
+ if (AccurateMath.sqrt(AccurateMath.abs(meanXSquared - meanX * meanX)) < accuracy) {
beta = 0;
} else {
beta = (meanXY - meanX * meanY) / (meanXSquared - meanX * meanX);
@@ -325,7 +325,7 @@ public class LoessInterpolator
final double alpha = meanY - beta * meanX;
res[i] = beta * x + alpha;
- residuals[i] = FastMath.abs(yval[i] - res[i]);
+ residuals[i] = AccurateMath.abs(yval[i] - res[i]);
}
// No need to recompute the robustness weights at the last
@@ -343,7 +343,7 @@ public class LoessInterpolator
Arrays.sort(sortedResiduals);
final double medianResidual = sortedResiduals[n / 2];
- if (FastMath.abs(medianResidual) < accuracy) {
+ if (AccurateMath.abs(medianResidual) < accuracy) {
break;
}
@@ -450,7 +450,7 @@ public class LoessInterpolator
* @return
* Given a non zero parameter value pval for the parameter, a reasonable value
- * for such a step is {@code pval * FastMath.sqrt(Precision.EPSILON)}.
+ * for such a step is {@code pval * AccurateMath.sqrt(Precision.EPSILON)}.
*
* 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 c65b03219..f0c9e4385 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
@@ -17,8 +17,8 @@
package org.apache.commons.math4.legacy.ode;
-import org.apache.commons.math4.legacy.Field;
-import org.apache.commons.math4.legacy.RealFieldElement;
+import org.apache.commons.math4.legacy.core.Field;
+import org.apache.commons.math4.legacy.core.RealFieldElement;
import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
import org.apache.commons.math4.legacy.exception.MathIllegalStateException;
import org.apache.commons.math4.legacy.exception.MaxCountExceededException;
@@ -30,8 +30,8 @@ import org.apache.commons.math4.legacy.ode.nonstiff.AdaptiveStepsizeFieldIntegra
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.util.FastMath;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* This class is the base class for multistep integrators for Ordinary
@@ -139,7 +139,7 @@ public abstract class MultistepFieldIntegrator This class is used by {@link AdamsBashforthIntegrator Adams-Bashforth} and
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 94648d04d..c13624561 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
@@ -17,8 +17,8 @@
package org.apache.commons.math4.legacy.ode.nonstiff;
-import org.apache.commons.math4.legacy.Field;
-import org.apache.commons.math4.legacy.RealFieldElement;
+import org.apache.commons.math4.legacy.core.Field;
+import org.apache.commons.math4.legacy.core.RealFieldElement;
import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
import org.apache.commons.math4.legacy.exception.MaxCountExceededException;
import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
@@ -27,8 +27,8 @@ import org.apache.commons.math4.legacy.ode.AbstractFieldIntegrator;
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.util.FastMath;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* This abstract class holds the common part of all adaptive
@@ -159,8 +159,8 @@ public abstract class AdaptiveStepsizeFieldIntegrator Adapter for mapping bounded {@link MultivariateFunction} to unbounded ones. Adapter extending bounded {@link MultivariateFunction} to an unbouded
@@ -174,7 +174,7 @@ public class MultivariateFunctionPenaltyAdapter
} else {
overshoot = 0;
}
- sum += FastMath.sqrt(overshoot);
+ sum += AccurateMath.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 b4e8585bd..888a44146 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.linear.RealVector;
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Powell's BOBYQA algorithm. This implementation is translated and
@@ -317,7 +317,7 @@ public class BOBYQAOptimizer
lowerDifference.setEntry(j, -initialTrustRegionRadius);
// Computing MAX
final double deltaOne = upperBound[j] - currentBest.getEntry(j);
- upperDifference.setEntry(j, FastMath.max(deltaOne, initialTrustRegionRadius));
+ upperDifference.setEntry(j, AccurateMath.max(deltaOne, initialTrustRegionRadius));
}
} else if (upperDifference.getEntry(j) <= initialTrustRegionRadius) {
if (upperDifference.getEntry(j) <= ZERO) {
@@ -329,7 +329,7 @@ public class BOBYQAOptimizer
// Computing MIN
final double deltaOne = lowerBound[j] - currentBest.getEntry(j);
final double deltaTwo = -initialTrustRegionRadius;
- lowerDifference.setEntry(j, FastMath.min(deltaOne, deltaTwo));
+ lowerDifference.setEntry(j, AccurateMath.min(deltaOne, deltaTwo));
upperDifference.setEntry(j, initialTrustRegionRadius);
}
}
@@ -501,8 +501,8 @@ public class BOBYQAOptimizer
// Computing MIN
double deltaOne = delta;
- double deltaTwo = FastMath.sqrt(dsq);
- dnorm = FastMath.min(deltaOne, deltaTwo);
+ double deltaTwo = AccurateMath.sqrt(dsq);
+ dnorm = AccurateMath.min(deltaOne, deltaTwo);
if (dnorm < HALF * rho) {
ntrits = -1;
// Computing 2nd power
@@ -519,8 +519,8 @@ public class BOBYQAOptimizer
// of likely improvements to the model within distance HALF*RHO of XOPT.
// Computing MAX
- deltaOne = FastMath.max(diffa, diffb);
- final double errbig = FastMath.max(deltaOne, diffc);
+ deltaOne = AccurateMath.max(diffa, diffb);
+ final double errbig = AccurateMath.max(deltaOne, diffc);
final double frhosq = rho * ONE_OVER_EIGHT * rho;
if (crvmin > ZERO &&
errbig > frhosq * crvmin) {
@@ -794,7 +794,7 @@ public class BOBYQAOptimizer
// Computing MAX
// Computing 2nd power
final double d4 = distsq / delsq;
- final double temp = FastMath.max(ONE, d4 * d4);
+ final double temp = AccurateMath.max(ONE, d4 * d4);
if (temp * den > scaden) {
scaden = temp * den;
knew = k;
@@ -803,7 +803,7 @@ public class BOBYQAOptimizer
// Computing MAX
// Computing 2nd power
final double d5 = lagrangeValuesAtNewPoint.getEntry(k);
- biglsq = FastMath.max(biglsq, temp * (d5 * d5));
+ biglsq = AccurateMath.max(biglsq, temp * (d5 * d5));
}
}
@@ -821,9 +821,9 @@ public class BOBYQAOptimizer
// Computing MAX
final double d3 = lowerBound[i];
final double d4 = originShift.getEntry(i) + newPoint.getEntry(i);
- final double d1 = FastMath.max(d3, d4);
+ final double d1 = AccurateMath.max(d3, d4);
final double d2 = upperBound[i];
- currentBest.setEntry(i, FastMath.min(d1, d2));
+ currentBest.setEntry(i, AccurateMath.min(d1, d2));
if (newPoint.getEntry(i) == lowerDifference.getEntry(i)) {
currentBest.setEntry(i, lowerBound[i]);
}
@@ -868,7 +868,7 @@ public class BOBYQAOptimizer
final double diff = f - fopt - vquad;
diffc = diffb;
diffb = diffa;
- diffa = FastMath.abs(diff);
+ diffa = AccurateMath.abs(diff);
if (dnorm > rho) {
nfsav = getEvaluations();
}
@@ -883,13 +883,13 @@ public class BOBYQAOptimizer
final double hDelta = HALF * delta;
if (ratio <= ONE_OVER_TEN) {
// Computing MIN
- delta = FastMath.min(hDelta, dnorm);
+ delta = AccurateMath.min(hDelta, dnorm);
} else if (ratio <= .7) {
// Computing MAX
- delta = FastMath.max(hDelta, dnorm);
+ delta = AccurateMath.max(hDelta, dnorm);
} else {
// Computing MAX
- delta = FastMath.max(hDelta, 2 * dnorm);
+ delta = AccurateMath.max(hDelta, 2 * dnorm);
}
if (delta <= rho * 1.5) {
delta = rho;
@@ -923,7 +923,7 @@ public class BOBYQAOptimizer
// Computing MAX
// Computing 2nd power
final double d3 = distsq / delsq;
- final double temp = FastMath.max(ONE, d3 * d3);
+ final double temp = AccurateMath.max(ONE, d3 * d3);
if (temp * den > scaden) {
scaden = temp * den;
knew = k;
@@ -933,7 +933,7 @@ public class BOBYQAOptimizer
// Computing 2nd power
final double d4 = lagrangeValuesAtNewPoint.getEntry(k);
final double d5 = temp * (d4 * d4);
- biglsq = FastMath.max(biglsq, d5);
+ biglsq = AccurateMath.max(biglsq, d5);
}
if (scaden <= HALF * biglsq) {
knew = ksav;
@@ -1058,18 +1058,18 @@ public class BOBYQAOptimizer
if (trustRegionCenterOffset.getEntry(i) == lowerDifference.getEntry(i)) {
// Computing MIN
// Computing 2nd power
- final double d1 = FastMath.min(ZERO, gradientAtTrustRegionCenter.getEntry(i));
+ final double d1 = AccurateMath.min(ZERO, gradientAtTrustRegionCenter.getEntry(i));
gqsq += d1 * d1;
// Computing 2nd power
- final double d2 = FastMath.min(ZERO, sum);
+ final double d2 = AccurateMath.min(ZERO, sum);
gisq += d2 * d2;
} else if (trustRegionCenterOffset.getEntry(i) == upperDifference.getEntry(i)) {
// Computing MAX
// Computing 2nd power
- final double d1 = FastMath.max(ZERO, gradientAtTrustRegionCenter.getEntry(i));
+ final double d1 = AccurateMath.max(ZERO, gradientAtTrustRegionCenter.getEntry(i));
gqsq += d1 * d1;
// Computing 2nd power
- final double d2 = FastMath.max(ZERO, sum);
+ final double d2 = AccurateMath.max(ZERO, sum);
gisq += d2 * d2;
} else {
// Computing 2nd power
@@ -1088,7 +1088,7 @@ public class BOBYQAOptimizer
itest = 0;
}
if (itest >= 3) {
- for (int i = 0, max = FastMath.max(npt, nh); i < max; i++) {
+ for (int i = 0, max = AccurateMath.max(npt, nh); i < max; i++) {
if (i < n) {
gradientAtTrustRegionCenter.setEntry(i, lagrangeValuesAtNewPoint.getEntry(npt + i));
}
@@ -1122,7 +1122,7 @@ public class BOBYQAOptimizer
final double d1 = TWO * delta;
// Computing 2nd power
final double d2 = TEN * rho;
- distsq = FastMath.max(d1 * d1, d2 * d2);
+ distsq = AccurateMath.max(d1 * d1, d2 * d2);
}
case 650: {
printState(650); // XXX
@@ -1147,10 +1147,10 @@ public class BOBYQAOptimizer
// current RHO are complete.
if (knew >= 0) {
- final double dist = FastMath.sqrt(distsq);
+ final double dist = AccurateMath.sqrt(distsq);
if (ntrits == -1) {
// Computing MIN
- delta = FastMath.min(ONE_OVER_TEN * delta, HALF * dist);
+ delta = AccurateMath.min(ONE_OVER_TEN * delta, HALF * dist);
if (delta <= rho * 1.5) {
delta = rho;
}
@@ -1158,8 +1158,8 @@ public class BOBYQAOptimizer
ntrits = 0;
// Computing MAX
// Computing MIN
- final double d1 = FastMath.min(ONE_OVER_TEN * dist, delta);
- adelt = FastMath.max(d1, rho);
+ final double d1 = AccurateMath.min(ONE_OVER_TEN * dist, delta);
+ adelt = AccurateMath.max(d1, rho);
dsq = adelt * adelt;
state = 90; break;
}
@@ -1169,7 +1169,7 @@ public class BOBYQAOptimizer
if (ratio > ZERO) {
state = 60; break;
}
- if (FastMath.max(delta, dnorm) > rho) {
+ if (AccurateMath.max(delta, dnorm) > rho) {
state = 60; break;
}
@@ -1184,11 +1184,11 @@ public class BOBYQAOptimizer
if (ratio <= SIXTEEN) {
rho = stoppingTrustRegionRadius;
} else if (ratio <= TWO_HUNDRED_FIFTY) {
- rho = FastMath.sqrt(ratio) * stoppingTrustRegionRadius;
+ rho = AccurateMath.sqrt(ratio) * stoppingTrustRegionRadius;
} else {
rho *= ONE_OVER_TEN;
}
- delta = FastMath.max(delta, rho);
+ delta = AccurateMath.max(delta, rho);
ntrits = 0;
nfsav = getEvaluations();
state = 60; break;
@@ -1209,9 +1209,9 @@ public class BOBYQAOptimizer
// Computing MAX
final double d3 = lowerBound[i];
final double d4 = originShift.getEntry(i) + trustRegionCenterOffset.getEntry(i);
- final double d1 = FastMath.max(d3, d4);
+ final double d1 = AccurateMath.max(d3, d4);
final double d2 = upperBound[i];
- currentBest.setEntry(i, FastMath.min(d1, d2));
+ currentBest.setEntry(i, AccurateMath.min(d1, d2));
if (trustRegionCenterOffset.getEntry(i) == lowerDifference.getEntry(i)) {
currentBest.setEntry(i, lowerBound[i]);
}
@@ -1328,11 +1328,11 @@ public class BOBYQAOptimizer
dderiv += glag.getEntry(i) * tmp;
distsq += tmp * tmp;
}
- double subd = adelt / FastMath.sqrt(distsq);
+ double subd = adelt / AccurateMath.sqrt(distsq);
double slbd = -subd;
int ilbd = 0;
int iubd = 0;
- final double sumin = FastMath.min(ONE, subd);
+ final double sumin = AccurateMath.min(ONE, subd);
// Revise SLBD and SUBD if necessary because of the bounds in SL and SU.
@@ -1345,7 +1345,7 @@ public class BOBYQAOptimizer
}
if (subd * tmp > upperDifference.getEntry(i) - trustRegionCenterOffset.getEntry(i)) {
// Computing MAX
- subd = FastMath.max(sumin,
+ subd = AccurateMath.max(sumin,
(upperDifference.getEntry(i) - trustRegionCenterOffset.getEntry(i)) / tmp);
iubd = i + 1;
}
@@ -1356,7 +1356,7 @@ public class BOBYQAOptimizer
}
if (subd * tmp < lowerDifference.getEntry(i) - trustRegionCenterOffset.getEntry(i)) {
// Computing MAX
- subd = FastMath.max(sumin,
+ subd = AccurateMath.max(sumin,
(lowerDifference.getEntry(i) - trustRegionCenterOffset.getEntry(i)) / tmp);
iubd = -i - 1;
}
@@ -1373,7 +1373,7 @@ public class BOBYQAOptimizer
final double diff = dderiv - ONE;
vlag = slbd * (dderiv - slbd * diff);
final double d1 = subd * (dderiv - subd * diff);
- if (FastMath.abs(d1) > FastMath.abs(vlag)) {
+ if (AccurateMath.abs(d1) > AccurateMath.abs(vlag)) {
step = subd;
vlag = d1;
isbd = iubd;
@@ -1383,7 +1383,7 @@ public class BOBYQAOptimizer
final double d4 = d2 - diff * subd;
if (d3 * d4 < ZERO) {
final double d5 = d2 * d2 / diff;
- if (FastMath.abs(d5) > FastMath.abs(vlag)) {
+ if (AccurateMath.abs(d5) > AccurateMath.abs(vlag)) {
step = d2 / diff;
vlag = d5;
isbd = 0;
@@ -1395,12 +1395,12 @@ public class BOBYQAOptimizer
} else {
vlag = slbd * (ONE - slbd);
final double tmp = subd * (ONE - subd);
- if (FastMath.abs(tmp) > FastMath.abs(vlag)) {
+ if (AccurateMath.abs(tmp) > AccurateMath.abs(vlag)) {
step = subd;
vlag = tmp;
isbd = iubd;
}
- if (subd > HALF && FastMath.abs(vlag) < ONE_OVER_FOUR) {
+ if (subd > HALF && AccurateMath.abs(vlag) < ONE_OVER_FOUR) {
step = HALF;
vlag = ONE_OVER_FOUR;
isbd = 0;
@@ -1424,8 +1424,8 @@ public class BOBYQAOptimizer
for (int i = 0; i < n; i++) {
final double tmp = trustRegionCenterOffset.getEntry(i) + stpsav * (interpolationPoints.getEntry(ksav, i) - trustRegionCenterOffset.getEntry(i));
- newPoint.setEntry(i, FastMath.max(lowerDifference.getEntry(i),
- FastMath.min(upperDifference.getEntry(i), tmp)));
+ newPoint.setEntry(i, AccurateMath.max(lowerDifference.getEntry(i),
+ AccurateMath.min(upperDifference.getEntry(i), tmp)));
}
if (ibdsav < 0) {
newPoint.setEntry(-ibdsav - 1, lowerDifference.getEntry(-ibdsav - 1));
@@ -1448,8 +1448,8 @@ public class BOBYQAOptimizer
for (int i = 0; i < n; i++) {
final double glagValue = glag.getEntry(i);
work1.setEntry(i, ZERO);
- if (FastMath.min(trustRegionCenterOffset.getEntry(i) - lowerDifference.getEntry(i), glagValue) > ZERO ||
- FastMath.max(trustRegionCenterOffset.getEntry(i) - upperDifference.getEntry(i), glagValue) < ZERO) {
+ if (AccurateMath.min(trustRegionCenterOffset.getEntry(i) - lowerDifference.getEntry(i), glagValue) > ZERO ||
+ AccurateMath.max(trustRegionCenterOffset.getEntry(i) - upperDifference.getEntry(i), glagValue) < ZERO) {
work1.setEntry(i, bigstp);
// Computing 2nd power
ggfree += glagValue * glagValue;
@@ -1462,7 +1462,7 @@ public class BOBYQAOptimizer
// Investigate whether more components of W can be fixed.
final double tmp1 = adelt * adelt - wfixsq;
if (tmp1 > ZERO) {
- step = FastMath.sqrt(tmp1 / ggfree);
+ step = AccurateMath.sqrt(tmp1 / ggfree);
ggfree = ZERO;
for (int i = 0; i < n; i++) {
if (work1.getEntry(i) == bigstp) {
@@ -1494,9 +1494,9 @@ public class BOBYQAOptimizer
final double glagValue = glag.getEntry(i);
if (work1.getEntry(i) == bigstp) {
work1.setEntry(i, -step * glagValue);
- final double min = FastMath.min(upperDifference.getEntry(i),
+ final double min = AccurateMath.min(upperDifference.getEntry(i),
trustRegionCenterOffset.getEntry(i) + work1.getEntry(i));
- alternativeNewPoint.setEntry(i, FastMath.max(lowerDifference.getEntry(i), min));
+ alternativeNewPoint.setEntry(i, AccurateMath.max(lowerDifference.getEntry(i), min));
} else if (work1.getEntry(i) == ZERO) {
alternativeNewPoint.setEntry(i, trustRegionCenterOffset.getEntry(i));
} else if (glagValue > ZERO) {
@@ -1524,12 +1524,12 @@ public class BOBYQAOptimizer
curv = -curv;
}
if (curv > -gw &&
- curv < -gw * (ONE + FastMath.sqrt(TWO))) {
+ curv < -gw * (ONE + AccurateMath.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, FastMath.max(lowerDifference.getEntry(i),
- FastMath.min(upperDifference.getEntry(i), tmp)));
+ alternativeNewPoint.setEntry(i, AccurateMath.max(lowerDifference.getEntry(i),
+ AccurateMath.min(upperDifference.getEntry(i), tmp)));
}
// Computing 2nd power
final double d1 = HALF * gw * scale;
@@ -1648,11 +1648,11 @@ public class BOBYQAOptimizer
stepa = interpolationPoints.getEntry(nfx, nfxm);
stepb = -initialTrustRegionRadius;
if (lowerDifference.getEntry(nfxm) == ZERO) {
- stepb = FastMath.min(TWO * initialTrustRegionRadius, upperDifference.getEntry(nfxm));
+ stepb = AccurateMath.min(TWO * initialTrustRegionRadius, upperDifference.getEntry(nfxm));
// throw new PathIsExploredException(); // XXX
}
if (upperDifference.getEntry(nfxm) == ZERO) {
- stepb = FastMath.max(-TWO * initialTrustRegionRadius, lowerDifference.getEntry(nfxm));
+ stepb = AccurateMath.max(-TWO * initialTrustRegionRadius, lowerDifference.getEntry(nfxm));
// throw new PathIsExploredException(); // XXX
}
interpolationPoints.setEntry(nfm, nfxm, stepb);
@@ -1677,7 +1677,7 @@ public class BOBYQAOptimizer
// its index are required.
for (int j = 0; j < n; j++) {
- currentBest.setEntry(j, FastMath.min(FastMath.max(lowerBound[j],
+ currentBest.setEntry(j, AccurateMath.min(AccurateMath.max(lowerBound[j],
originShift.getEntry(j) + interpolationPoints.getEntry(nfm, j)),
upperBound[j]));
if (interpolationPoints.getEntry(nfm, j) == lowerDifference.getEntry(j)) {
@@ -1736,9 +1736,9 @@ public class BOBYQAOptimizer
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, FastMath.sqrt(TWO) / (stepa * stepb));
- zMatrix.setEntry(nfm, nfxm, FastMath.sqrt(HALF) / rhosq);
- // zMatrix.setEntry(nfm, nfxm, FastMath.sqrt(HALF) * recip); // XXX "testAckley" and "testDiffPow" fail.
+ 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(nfm - n, nfxm,
-zMatrix.getEntry(0, nfxm) - zMatrix.getEntry(nfm, nfxm));
}
@@ -1935,7 +1935,7 @@ public class BOBYQAOptimizer
if (resid <= ZERO) {
state = 90; break;
}
- temp = FastMath.sqrt(stepsq * resid + ds * ds);
+ temp = AccurateMath.sqrt(stepsq * resid + ds * ds);
if (ds < ZERO) {
blen = (temp - ds) / stepsq;
} else {
@@ -1944,7 +1944,7 @@ public class BOBYQAOptimizer
stplen = blen;
if (shs > ZERO) {
// Computing MIN
- stplen = FastMath.min(blen, gredsq / shs);
+ stplen = AccurateMath.min(blen, gredsq / shs);
}
// Reduce STPLEN if necessary in order to preserve the simple bounds,
@@ -1973,7 +1973,7 @@ public class BOBYQAOptimizer
++iterc;
temp = shs / stepsq;
if (iact == -1 && temp > ZERO) {
- crvmin = FastMath.min(crvmin,temp);
+ crvmin = AccurateMath.min(crvmin,temp);
if (crvmin == MINUS_ONE) {
crvmin = temp;
}
@@ -1991,7 +1991,7 @@ public class BOBYQAOptimizer
}
// Computing MAX
final double d1 = stplen * (ggsav - HALF * stplen * shs);
- sdec = FastMath.max(d1, ZERO);
+ sdec = AccurateMath.max(d1, ZERO);
qred += sdec;
}
@@ -2069,7 +2069,7 @@ public class BOBYQAOptimizer
if (temp <= qred * 1e-4 * qred) {
state = 190; break;
}
- temp = FastMath.sqrt(temp);
+ temp = AccurateMath.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);
@@ -2108,7 +2108,7 @@ public class BOBYQAOptimizer
d1 = trustRegionCenterOffset.getEntry(i) - lowerDifference.getEntry(i);
temp = ssq - d1 * d1;
if (temp > ZERO) {
- temp = FastMath.sqrt(temp) - s.getEntry(i);
+ temp = AccurateMath.sqrt(temp) - s.getEntry(i);
if (angbd * temp > tempa) {
angbd = tempa / temp;
iact = i;
@@ -2119,7 +2119,7 @@ public class BOBYQAOptimizer
d1 = upperDifference.getEntry(i) - trustRegionCenterOffset.getEntry(i);
temp = ssq - d1 * d1;
if (temp > ZERO) {
- temp = FastMath.sqrt(temp) + s.getEntry(i);
+ temp = AccurateMath.sqrt(temp) + s.getEntry(i);
if (angbd * temp > tempb) {
angbd = tempb / temp;
iact = i;
@@ -2224,9 +2224,9 @@ public class BOBYQAOptimizer
for (int i = 0; i < n; i++) {
// Computing MAX
// Computing MIN
- final double min = FastMath.min(trustRegionCenterOffset.getEntry(i) + trialStepPoint.getEntry(i),
+ final double min = AccurateMath.min(trustRegionCenterOffset.getEntry(i) + trialStepPoint.getEntry(i),
upperDifference.getEntry(i));
- newPoint.setEntry(i, FastMath.max(min, lowerDifference.getEntry(i)));
+ newPoint.setEntry(i, AccurateMath.max(min, lowerDifference.getEntry(i)));
if (xbdi.getEntry(i) == MINUS_ONE) {
newPoint.setEntry(i, lowerDifference.getEntry(i));
}
@@ -2315,7 +2315,7 @@ public class BOBYQAOptimizer
for (int k = 0; k < npt; k++) {
for (int j = 0; j < nptm; j++) {
// Computing MAX
- ztest = FastMath.max(ztest, FastMath.abs(zMatrix.getEntry(k, j)));
+ ztest = AccurateMath.max(ztest, AccurateMath.abs(zMatrix.getEntry(k, j)));
}
}
ztest *= 1e-20;
@@ -2324,12 +2324,12 @@ public class BOBYQAOptimizer
for (int j = 1; j < nptm; j++) {
final double d1 = zMatrix.getEntry(knew, j);
- if (FastMath.abs(d1) > ztest) {
+ if (AccurateMath.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 = FastMath.sqrt(d2 * d2 + d3 * d3);
+ final double d4 = AccurateMath.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++) {
@@ -2353,7 +2353,7 @@ public class BOBYQAOptimizer
// Complete the updating of ZMAT.
- final double sqrtDenom = FastMath.sqrt(denom);
+ final double sqrtDenom = AccurateMath.sqrt(denom);
final double d1 = tau / sqrtDenom;
final double d2 = zMatrix.getEntry(knew, 0) / sqrtDenom;
for (int i = 0; i < npt; i++) {
@@ -2412,7 +2412,7 @@ public class BOBYQAOptimizer
double minDiff = Double.POSITIVE_INFINITY;
for (int i = 0; i < dimension; i++) {
boundDifference[i] = upperBound[i] - lowerBound[i];
- minDiff = FastMath.min(minDiff, boundDifference[i]);
+ minDiff = AccurateMath.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 43575d94a..79ee03e65 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
@@ -38,7 +38,7 @@ import org.apache.commons.math4.legacy.optim.nonlinear.scalar.MultivariateOptimi
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* An implementation of the active Covariance Matrix Adaptation Evolution Strategy (CMA-ES)
@@ -443,7 +443,7 @@ public class CMAESOptimizer
updateCovarianceDiagonalOnly(hsig, bestArz);
}
// Adapt step size sigma - Eq. (5)
- sigma *= FastMath.exp(FastMath.min(1, (normps/chiN - 1) * cs / damps));
+ sigma *= AccurateMath.exp(AccurateMath.min(1, (normps/chiN - 1) * cs / damps));
final double bestFitness = fitness[arindex[0]];
final double worstFitness = fitness[arindex[arindex.length - 1]];
if (bestValue > bestFitness) {
@@ -464,7 +464,7 @@ public class CMAESOptimizer
final double[] sqrtDiagC = sqrt(diagC).getColumn(0);
final double[] pcCol = pc.getColumn(0);
for (int i = 0; i < dimension; i++) {
- if (sigma * FastMath.max(FastMath.abs(pcCol[i]), sqrtDiagC[i]) > stopTolX) {
+ if (sigma * AccurateMath.max(AccurateMath.abs(pcCol[i]), sqrtDiagC[i]) > stopTolX) {
break;
}
if (i >= dimension - 1) {
@@ -479,8 +479,8 @@ public class CMAESOptimizer
final double historyBest = min(fitnessHistory);
final double historyWorst = max(fitnessHistory);
if (iterations > 2 &&
- FastMath.max(historyWorst, worstFitness) -
- FastMath.min(historyBest, bestFitness) < stopTolFun) {
+ AccurateMath.max(historyWorst, worstFitness) -
+ AccurateMath.min(historyBest, bestFitness) < stopTolFun) {
break generationLoop;
}
if (iterations > fitnessHistory.length &&
@@ -504,11 +504,11 @@ public class CMAESOptimizer
}
// Adjust step size in case of equal function values (flat fitness)
if (bestValue == fitness[arindex[(int)(0.1+lambda/4.)]]) {
- sigma *= FastMath.exp(0.2 + cs / damps);
+ sigma *= AccurateMath.exp(0.2 + cs / damps);
}
- if (iterations > 2 && FastMath.max(historyWorst, bestFitness) -
- FastMath.min(historyBest, bestFitness) == 0) {
- sigma *= FastMath.exp(0.2 + cs / damps);
+ if (iterations > 2 && AccurateMath.max(historyWorst, bestFitness) -
+ AccurateMath.min(historyBest, bestFitness) == 0) {
+ sigma *= AccurateMath.exp(0.2 + cs / damps);
}
// store best in history
push(fitnessHistory,bestFitness);
@@ -600,7 +600,7 @@ public class CMAESOptimizer
// initialize selection strategy parameters
mu = lambda / 2; // number of parents/points for recombination
- logMu2 = FastMath.log(mu + 0.5);
+ logMu2 = AccurateMath.log(mu + 0.5);
weights = log(sequence(1, mu, 1)).scalarMultiply(-1).scalarAdd(logMu2);
double sumw = 0;
double sumwq = 0;
@@ -616,16 +616,16 @@ public class CMAESOptimizer
cc = (4 + mueff / dimension) /
(dimension + 4 + 2 * mueff / dimension);
cs = (mueff + 2) / (dimension + mueff + 3.);
- damps = (1 + 2 * FastMath.max(0, FastMath.sqrt((mueff - 1) /
+ damps = (1 + 2 * AccurateMath.max(0, AccurateMath.sqrt((mueff - 1) /
(dimension + 1)) - 1)) *
- FastMath.max(0.3,
+ AccurateMath.max(0.3,
1 - dimension / (1e-6 + maxIterations)) + cs; // minor increment
ccov1 = 2 / ((dimension + 1.3) * (dimension + 1.3) + mueff);
- ccovmu = FastMath.min(1 - ccov1, 2 * (mueff - 2 + 1 / mueff) /
+ ccovmu = AccurateMath.min(1 - ccov1, 2 * (mueff - 2 + 1 / mueff) /
((dimension + 2) * (dimension + 2) + mueff));
- ccov1Sep = FastMath.min(1, ccov1 * (dimension + 1.5) / 3);
- ccovmuSep = FastMath.min(1 - ccov1, ccovmu * (dimension + 1.5) / 3);
- chiN = FastMath.sqrt(dimension) *
+ ccov1Sep = AccurateMath.min(1, ccov1 * (dimension + 1.5) / 3);
+ ccovmuSep = AccurateMath.min(1 - ccov1, ccovmu * (dimension + 1.5) / 3);
+ chiN = AccurateMath.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
@@ -657,14 +657,14 @@ public class CMAESOptimizer
private boolean updateEvolutionPaths(RealMatrix zmean, RealMatrix xold) {
ps = ps.scalarMultiply(1 - cs).add(
B.multiply(zmean).scalarMultiply(
- FastMath.sqrt(cs * (2 - cs) * mueff)));
+ AccurateMath.sqrt(cs * (2 - cs) * mueff)));
normps = ps.getFrobeniusNorm();
final boolean hsig = normps /
- FastMath.sqrt(1 - FastMath.pow(1 - cs, 2 * iterations)) /
+ AccurateMath.sqrt(1 - AccurateMath.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(FastMath.sqrt(cc * (2 - cc) * mueff) / sigma));
+ pc = pc.add(xmean.subtract(xold).scalarMultiply(AccurateMath.sqrt(cc * (2 - cc) * mueff) / sigma));
}
return hsig;
}
@@ -722,7 +722,7 @@ public class CMAESOptimizer
if (isActiveCMA) {
// Adapt covariance matrix C active CMA
negccov = (1 - ccovmu) * 0.25 * mueff /
- (FastMath.pow(dimension + 2, 1.5) + 2 * mueff);
+ (AccurateMath.pow(dimension + 2, 1.5) + 2 * mueff);
// keep at least 0.66 in all directions, small popsize are most
// critical
final double negminresidualvariance = 0.66;
@@ -1006,7 +1006,7 @@ public class CMAESOptimizer
private double penalty(final double[] x, final double[] repaired) {
double penalty = 0;
for (int i = 0; i < x.length; i++) {
- double diff = FastMath.abs(x[i] - repaired[i]);
+ double diff = AccurateMath.abs(x[i] - repaired[i]);
penalty += diff;
}
return isMinimize ? penalty : -penalty;
@@ -1023,7 +1023,7 @@ public class CMAESOptimizer
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] = FastMath.log(m.getEntry(r, c));
+ d[r][c] = AccurateMath.log(m.getEntry(r, c));
}
}
return new Array2DRowRealMatrix(d, false);
@@ -1037,7 +1037,7 @@ public class CMAESOptimizer
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] = FastMath.sqrt(m.getEntry(r, c));
+ d[r][c] = AccurateMath.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 6983bc569..5c185a6d5 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.GoalType;
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Powell's algorithm.
@@ -59,7 +59,7 @@ public class PowellOptimizer
/**
* Minimum relative tolerance.
*/
- private static final double MIN_RELATIVE_TOLERANCE = 2 * FastMath.ulp(1d);
+ private static final double MIN_RELATIVE_TOLERANCE = 2 * AccurateMath.ulp(1d);
/**
* Relative threshold.
*/
@@ -90,7 +90,7 @@ public class PowellOptimizer
public PowellOptimizer(double rel,
double abs,
ConvergenceChecker This class provides a stable normalized random generator. It samples from a stable
@@ -73,7 +73,7 @@ public class StableRandomGenerator implements NormalizedRandomGenerator {
this.alpha = alpha;
this.beta = beta;
if (alpha < 2d && beta != 0d) {
- zeta = beta * FastMath.tan(FastMath.PI * alpha / 2);
+ zeta = beta * AccurateMath.tan(AccurateMath.PI * alpha / 2);
} else {
zeta = 0d;
}
@@ -87,12 +87,12 @@ public class StableRandomGenerator implements NormalizedRandomGenerator {
@Override
public double nextNormalizedDouble() {
// we need 2 uniform random numbers to calculate omega and phi
- double omega = -FastMath.log(generator.nextDouble());
- double phi = FastMath.PI * (generator.nextDouble() - 0.5);
+ double omega = -AccurateMath.log(generator.nextDouble());
+ double phi = AccurateMath.PI * (generator.nextDouble() - 0.5);
// Normal distribution case (Box-Muller algorithm)
if (alpha == 2d) {
- return FastMath.sqrt(2d * omega) * FastMath.sin(phi);
+ return AccurateMath.sqrt(2d * omega) * AccurateMath.sin(phi);
}
double x;
@@ -101,30 +101,30 @@ public class StableRandomGenerator implements NormalizedRandomGenerator {
if (beta == 0d) {
// Cauchy distribution case
if (alpha == 1d) {
- x = FastMath.tan(phi);
+ x = AccurateMath.tan(phi);
} else {
- x = FastMath.pow(omega * FastMath.cos((1 - alpha) * phi),
+ x = AccurateMath.pow(omega * AccurateMath.cos((1 - alpha) * phi),
1d / alpha - 1d) *
- FastMath.sin(alpha * phi) /
- FastMath.pow(FastMath.cos(phi), 1d / alpha);
+ AccurateMath.sin(alpha * phi) /
+ AccurateMath.pow(AccurateMath.cos(phi), 1d / alpha);
}
} else {
// Generic stable distribution
- double cosPhi = FastMath.cos(phi);
+ double cosPhi = AccurateMath.cos(phi);
// to avoid rounding errors around alpha = 1
- if (FastMath.abs(alpha - 1d) > 1e-8) {
+ if (AccurateMath.abs(alpha - 1d) > 1e-8) {
double alphaPhi = alpha * phi;
double invAlphaPhi = phi - alphaPhi;
- x = (FastMath.sin(alphaPhi) + zeta * FastMath.cos(alphaPhi)) / cosPhi *
- (FastMath.cos(invAlphaPhi) + zeta * FastMath.sin(invAlphaPhi)) /
- FastMath.pow(omega * cosPhi, (1 - alpha) / alpha);
+ x = (AccurateMath.sin(alphaPhi) + zeta * AccurateMath.cos(alphaPhi)) / cosPhi *
+ (AccurateMath.cos(invAlphaPhi) + zeta * AccurateMath.sin(invAlphaPhi)) /
+ AccurateMath.pow(omega * cosPhi, (1 - alpha) / alpha);
} else {
- double betaPhi = FastMath.PI / 2 + beta * phi;
- x = 2d / FastMath.PI * (betaPhi * FastMath.tan(phi) - beta *
- FastMath.log(FastMath.PI / 2d * omega * cosPhi / betaPhi));
+ double betaPhi = AccurateMath.PI / 2 + beta * phi;
+ x = 2d / AccurateMath.PI * (betaPhi * AccurateMath.tan(phi) - beta *
+ AccurateMath.log(AccurateMath.PI / 2d * omega * cosPhi / betaPhi));
if (alpha != 1d) {
- x += beta * FastMath.tan(FastMath.PI * alpha / 2);
+ x += beta * AccurateMath.tan(AccurateMath.PI * alpha / 2);
}
}
}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/random/UniformRandomGenerator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/random/UniformRandomGenerator.java
index 74ddb4947..a8ef51541 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/random/UniformRandomGenerator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/random/UniformRandomGenerator.java
@@ -17,7 +17,7 @@
package org.apache.commons.math4.legacy.random;
-import org.apache.commons.math4.legacy.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
import org.apache.commons.rng.UniformRandomProvider;
/**
@@ -33,7 +33,7 @@ import org.apache.commons.rng.UniformRandomProvider;
*/
public class UniformRandomGenerator implements NormalizedRandomGenerator {
/** Square root of three. */
- private static final double SQRT3 = FastMath.sqrt(3);
+ private static final double SQRT3 = AccurateMath.sqrt(3);
/** Underlying generator. */
private final UniformRandomProvider generator;
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 d2671bc47..7972f1242 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.analysis.UnivariateFunction;
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* This class provides computation methods related to Bessel
@@ -165,7 +165,7 @@ public class BesselJ
return res.vals[n];
} else if (res.nVals < 0) {
throw new MathIllegalArgumentException(LocalizedFormats.BESSEL_FUNCTION_BAD_ARGUMENT,order, x);
- } else if (FastMath.abs(res.vals[res.nVals - 1]) < 1e-100) {
+ } else if (AccurateMath.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 @@ public class BesselJ
halfx = 0.5 * x;
}
if (alpha != 0) {
- tempa = FastMath.pow(halfx, alpha) /
+ tempa = AccurateMath.pow(halfx, alpha) /
(alpha * Gamma.value(alpha));
}
tempb = 0;
@@ -323,7 +323,7 @@ public class BesselJ
// ---------------------------------------------------------------------
// Asymptotic series for X > 25
// ---------------------------------------------------------------------
- final double xc = FastMath.sqrt(PI2 / x);
+ final double xc = AccurateMath.sqrt(PI2 / x);
final double mul = 0.125 / x;
final double xin = mul * mul;
int m = 0;
@@ -341,8 +341,8 @@ public class BesselJ
// ---------------------------------------------------------------------
double t = (double) ((int) ((x / TWOPI) + 0.5));
final double z = x - t * TOWPI1 - t * TWOPI2 - (alpha + 0.5) / PI2;
- double vsin = FastMath.sin(z);
- double vcos = FastMath.cos(z);
+ double vsin = AccurateMath.sin(z);
+ double vcos = AccurateMath.cos(z);
double gnu = 2 * alpha;
double capq;
double capp;
@@ -457,7 +457,7 @@ public class BesselJ
p = plast * tover;
n -= 1;
en -= 2.0;
- nend = FastMath.min(nb, n);
+ nend = AccurateMath.min(nb, n);
for (int l = nstart; l <= nend; l++) {
pold = psavel;
psavel = psave;
@@ -479,8 +479,8 @@ public class BesselJ
// ---------------------------------------------------------------------
// Calculate special significance test for NBMX > 2.
// ---------------------------------------------------------------------
- test = FastMath.max(test, FastMath.sqrt(plast * ENSIG) *
- FastMath.sqrt(2 * p));
+ test = AccurateMath.max(test, AccurateMath.sqrt(plast * ENSIG) *
+ AccurateMath.sqrt(2 * p));
}
}
// ---------------------------------------------------------------------
@@ -620,8 +620,8 @@ public class BesselJ
// Normalize. Divide all B(N) by sum.
// ---------------------------------------------------------------------
- if (FastMath.abs(alpha) > 1e-16) {
- sum *= Gamma.value(alpha) * FastMath.pow(x * 0.5, -alpha);
+ if (AccurateMath.abs(alpha) > 1e-16) {
+ sum *= Gamma.value(alpha) * AccurateMath.pow(x * 0.5, -alpha);
}
tempa = ENMTEN;
if (sum > 1) {
@@ -629,7 +629,7 @@ public class BesselJ
}
for (n = 0; n < nb; n++) {
- if (FastMath.abs(b[n]) < tempa) {
+ if (AccurateMath.abs(b[n]) < tempa) {
b[n] = 0;
}
b[n] /= sum;
@@ -642,7 +642,7 @@ public class BesselJ
if (b.length > 0) {
b[0] = 0;
}
- ncalc = FastMath.min(nb, 0) - 1;
+ ncalc = AccurateMath.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 4ac6d9da3..794742369 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.exception.DimensionMismatchException;
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
import org.apache.commons.math4.legacy.util.Pair;
/**
@@ -208,9 +208,9 @@ public class KendallsCorrelation {
for (int segmentSize = 1; segmentSize < n; segmentSize <<= 1) {
for (int offset = 0; offset < n; offset += 2 * segmentSize) {
int i = offset;
- final int iEnd = FastMath.min(i + segmentSize, n);
+ final int iEnd = AccurateMath.min(i + segmentSize, n);
int j = iEnd;
- final int jEnd = FastMath.min(j + segmentSize, n);
+ final int jEnd = AccurateMath.min(j + segmentSize, n);
int copyLocation = offset;
while (i < iEnd || j < jEnd) {
@@ -257,7 +257,7 @@ public class KendallsCorrelation {
final long concordantMinusDiscordant = numPairs - tiedXPairs - tiedYPairs + tiedXYPairs - 2 * swaps;
final double nonTiedPairsMultiplied = (numPairs - tiedXPairs) * (double) (numPairs - tiedYPairs);
- return concordantMinusDiscordant / FastMath.sqrt(nonTiedPairsMultiplied);
+ return concordantMinusDiscordant / AccurateMath.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 08084a0e6..dc68e48af 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.exception.util.LocalizedFormats;
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Computes Pearson's product-moment correlation coefficients for pairs of arrays
@@ -165,7 +165,7 @@ public class PearsonsCorrelation {
for (int i = 0; i < nVars; i++) {
for (int j = 0; j < nVars; j++) {
double r = correlationMatrix.getEntry(i, j);
- out[i][j] = FastMath.sqrt((1 - r * r) /(nObs - 2));
+ out[i][j] = AccurateMath.sqrt((1 - r * r) /(nObs - 2));
}
}
return new BlockRealMatrix(out);
@@ -201,7 +201,7 @@ public class PearsonsCorrelation {
out[i][j] = 0d;
} else {
double r = correlationMatrix.getEntry(i, j);
- double t = FastMath.abs(r * FastMath.sqrt((nObs - 2)/(1 - r * r)));
+ double t = AccurateMath.abs(r * AccurateMath.sqrt((nObs - 2)/(1 - r * r)));
out[i][j] = 2 * tDistribution.cumulativeProbability(-t);
}
}
@@ -300,11 +300,11 @@ public class PearsonsCorrelation {
int nVars = covarianceMatrix.getColumnDimension();
RealMatrix outMatrix = new BlockRealMatrix(nVars, nVars);
for (int i = 0; i < nVars; i++) {
- double sigma = FastMath.sqrt(covarianceMatrix.getEntry(i, i));
+ double sigma = AccurateMath.sqrt(covarianceMatrix.getEntry(i, i));
outMatrix.setEntry(i, i, 1d);
for (int j = 0; j < i; j++) {
double entry = covarianceMatrix.getEntry(i, j) /
- (sigma * FastMath.sqrt(covarianceMatrix.getEntry(j, j)));
+ (sigma * AccurateMath.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/AbstractStorelessUnivariateStatistic.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/AbstractStorelessUnivariateStatistic.java
index 0da1b10d8..a42f7689a 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/AbstractStorelessUnivariateStatistic.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/AbstractStorelessUnivariateStatistic.java
@@ -19,7 +19,7 @@ package org.apache.commons.math4.legacy.stat.descriptive;
import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
import org.apache.commons.math4.legacy.exception.NullArgumentException;
import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
import org.apache.commons.numbers.core.Precision;
/**
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/AbstractUnivariateStatistic.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/AbstractUnivariateStatistic.java
index d13f4acc4..b5f0afb18 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/AbstractUnivariateStatistic.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/AbstractUnivariateStatistic.java
@@ -21,7 +21,7 @@ import org.apache.commons.math4.legacy.exception.NotPositiveException;
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.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Abstract base class for implementations of the {@link UnivariateStatistic} interface.
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 d95a7d08c..f54f95a9e 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.Min;
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
@@ -272,7 +272,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
double stdDev = Double.NaN;
if (getN() > 0) {
if (getN() > 1) {
- stdDev = FastMath.sqrt(getVariance());
+ stdDev = AccurateMath.sqrt(getVariance());
} else {
stdDev = 0.0;
}
@@ -289,7 +289,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
*/
public double getQuadraticMean() {
final long n = getN();
- return n > 0 ? FastMath.sqrt(getSumsq() / n) : Double.NaN;
+ return n > 0 ? AccurateMath.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 ee2471f37..30284288a 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,8 +31,8 @@ import org.apache.commons.math4.legacy.stat.descriptive.rank.Min;
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.util.FastMath;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.legacy.core.MathArrays;
import org.apache.commons.numbers.core.Precision;
/**
@@ -255,7 +255,7 @@ public class MultivariateSummaryStatistics
} else {
RealMatrix matrix = covarianceImpl.getResult();
for (int i = 0; i < k; ++i) {
- stdDev[i] = FastMath.sqrt(matrix.getEntry(i, i));
+ stdDev[i] = AccurateMath.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 d68ea75fe..42153d1af 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,8 +25,8 @@ import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
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.util.FastMath;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* A variable length {@link DoubleArray} implementation that automatically
@@ -540,16 +540,16 @@ class ResizableDoubleArray implements DoubleArray, Serializable { // Not in publ
* after expansion will be {@code internalArray.length + expansionFactor}.
*/
protected void expand() {
- // notice the use of FastMath.ceil(), this guarantees that we will always
+ // notice the use of AccurateMath.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) FastMath.ceil(internalArray.length * expansionFactor);
+ newSize = (int) AccurateMath.ceil(internalArray.length * expansionFactor);
} else {
- newSize = (int) (internalArray.length + FastMath.round(expansionFactor));
+ newSize = (int) (internalArray.length + AccurateMath.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 cfd81170b..6cac22d92 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 @@ package org.apache.commons.math4.legacy.stat.descriptive;
import java.io.Serializable;
-import org.apache.commons.math4.legacy.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
import org.apache.commons.numbers.core.Precision;
/**
@@ -115,7 +115,7 @@ public class StatisticalSummaryValues implements Serializable,
*/
@Override
public double getStandardDeviation() {
- return FastMath.sqrt(variance);
+ return AccurateMath.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 224492e79..90629f3d6 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.rank.Min;
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
import org.apache.commons.numbers.core.Precision;
/**
@@ -219,7 +219,7 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
double stdDev = Double.NaN;
if (getN() > 0) {
if (getN() > 1) {
- stdDev = FastMath.sqrt(getVariance());
+ stdDev = AccurateMath.sqrt(getVariance());
} else {
stdDev = 0.0;
}
@@ -236,7 +236,7 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
*/
public double getQuadraticMean() {
final long size = getN();
- return size > 0 ? FastMath.sqrt(getSumsq() / size) : Double.NaN;
+ return size > 0 ? AccurateMath.sqrt(getSumsq() / size) : Double.NaN;
}
/**
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/UnivariateStatistic.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/UnivariateStatistic.java
index ab43612ac..eed0669d5 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/UnivariateStatistic.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/UnivariateStatistic.java
@@ -17,7 +17,7 @@
package org.apache.commons.math4.legacy.stat.descriptive;
import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
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 6a5507e3f..00dc11bd5 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.exception.util.LocalizedFormats;
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Returns the
@@ -108,7 +108,7 @@ public class GeometricMean extends AbstractStorelessUnivariateStatistic implemen
@Override
public double getResult() {
if (sumOfLogs.getN() > 0) {
- return FastMath.exp(sumOfLogs.getResult() / sumOfLogs.getN());
+ return AccurateMath.exp(sumOfLogs.getResult() / sumOfLogs.getN());
} else {
return Double.NaN;
}
@@ -141,7 +141,7 @@ public class GeometricMean extends AbstractStorelessUnivariateStatistic implemen
@Override
public double evaluate(final double[] values, final int begin, final int length)
throws MathIllegalArgumentException {
- return FastMath.exp(sumOfLogs.evaluate(values, begin, length) / length);
+ return AccurateMath.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 2791b9ff9..2d189461a 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,8 +21,8 @@ import java.io.Serializable;
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.util.FastMath;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
@@ -171,15 +171,15 @@ public class Kurtosis extends AbstractStorelessUnivariateStatistic implements S
Variance variance = new Variance();
variance.incrementAll(values, begin, length);
double mean = variance.moment.m1;
- double stdDev = FastMath.sqrt(variance.getResult());
+ double stdDev = AccurateMath.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 += FastMath.pow(values[i] - mean, 4.0);
+ accum3 += AccurateMath.pow(values[i] - mean, 4.0);
}
- accum3 /= FastMath.pow(stdDev, 4.0d);
+ accum3 /= AccurateMath.pow(stdDev, 4.0d);
// Get N
double n0 = length;
@@ -187,7 +187,7 @@ public class Kurtosis extends AbstractStorelessUnivariateStatistic implements S
double coefficientOne =
(n0 * (n0 + 1)) / ((n0 - 1) * (n0 - 2) * (n0 - 3));
double termTwo =
- (3 * FastMath.pow(n0 - 1, 2.0)) / ((n0 - 2) * (n0 - 3));
+ (3 * AccurateMath.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/Mean.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/Mean.java
index 82b23d2c7..91de459c4 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/Mean.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/Mean.java
@@ -23,7 +23,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.stat.descriptive.summary.Sum;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Computes the arithmetic mean of a set of values. Uses the definitional
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/SemiVariance.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/SemiVariance.java
index f590a841d..475a68be6 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/SemiVariance.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/SemiVariance.java
@@ -22,7 +22,7 @@ import java.io.Serializable;
import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
import org.apache.commons.math4.legacy.exception.NullArgumentException;
import org.apache.commons.math4.legacy.stat.descriptive.AbstractUnivariateStatistic;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Computes the semivariance of a set of values with respect to a given cutoff value.
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 204924517..7945614c7 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,8 +21,8 @@ import java.io.Serializable;
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.util.FastMath;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Computes the skewness of the available values.
@@ -120,7 +120,7 @@ public class Skewness extends AbstractStorelessUnivariateStatistic implements Se
} else {
double n0 = moment.getN();
return (n0 * moment.m3) /
- ((n0 - 1) * (n0 -2) * FastMath.sqrt(variance) * variance);
+ ((n0 - 1) * (n0 -2) * AccurateMath.sqrt(variance) * variance);
}
}
@@ -186,7 +186,7 @@ public class Skewness extends AbstractStorelessUnivariateStatistic implements Se
final double d = values[i] - m;
accum3 += d * d * d;
}
- accum3 /= variance * FastMath.sqrt(variance);
+ accum3 /= variance * AccurateMath.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 cae7c12ec..b747f77c8 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 java.io.Serializable;
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Computes the sample standard deviation. The standard deviation
@@ -125,7 +125,7 @@ public class StandardDeviation extends AbstractStorelessUnivariateStatistic
*/
@Override
public double getResult() {
- return FastMath.sqrt(variance.getResult());
+ return AccurateMath.sqrt(variance.getResult());
}
/**
@@ -152,7 +152,7 @@ public class StandardDeviation extends AbstractStorelessUnivariateStatistic
*/
@Override
public double evaluate(final double[] values) throws MathIllegalArgumentException {
- return FastMath.sqrt(variance.evaluate(values));
+ return AccurateMath.sqrt(variance.evaluate(values));
}
/**
@@ -176,7 +176,7 @@ public class StandardDeviation extends AbstractStorelessUnivariateStatistic
@Override
public double evaluate(final double[] values, final int begin, final int length)
throws MathIllegalArgumentException {
- return FastMath.sqrt(variance.evaluate(values, begin, length));
+ return AccurateMath.sqrt(variance.evaluate(values, begin, length));
}
/**
@@ -205,7 +205,7 @@ public class StandardDeviation extends AbstractStorelessUnivariateStatistic
*/
public double evaluate(final double[] values, final double mean,
final int begin, final int length) throws MathIllegalArgumentException {
- return FastMath.sqrt(variance.evaluate(values, mean, begin, length));
+ return AccurateMath.sqrt(variance.evaluate(values, mean, begin, length));
}
/**
@@ -231,7 +231,7 @@ public class StandardDeviation extends AbstractStorelessUnivariateStatistic
*/
public double evaluate(final double[] values, final double mean)
throws MathIllegalArgumentException {
- return FastMath.sqrt(variance.evaluate(values, mean));
+ return AccurateMath.sqrt(variance.evaluate(values, mean));
}
/**
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/Variance.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/Variance.java
index a58810a8b..974051863 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/Variance.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/moment/Variance.java
@@ -23,7 +23,7 @@ import org.apache.commons.math4.legacy.exception.NullArgumentException;
import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
import org.apache.commons.math4.legacy.stat.descriptive.AbstractStorelessUnivariateStatistic;
import org.apache.commons.math4.legacy.stat.descriptive.WeightedEvaluation;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Computes the variance of the available values. By default, the unbiased
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/CentralPivotingStrategy.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/CentralPivotingStrategy.java
index 7632e3221..e6e0d2ad4 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/CentralPivotingStrategy.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/CentralPivotingStrategy.java
@@ -19,7 +19,7 @@ package org.apache.commons.math4.legacy.stat.descriptive.rank;
import java.io.Serializable;
import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* A mid point strategy based on the average of begin and end indices.
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 3b764a7ac..7e4877698 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.io.Serializable;
import java.util.Arrays;
import org.apache.commons.math4.legacy.exception.NullArgumentException;
-import org.apache.commons.math4.legacy.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* A Simple Kth selector implementation to pick up the
@@ -101,11 +101,11 @@ public class KthSelector implements Serializable {
} else if (k < pivot) {
// the element is in the left partition
end = pivot;
- node = FastMath.min(2 * node + 1, usePivotsHeap ? pivotsHeap.length : end);
+ node = AccurateMath.min(2 * node + 1, usePivotsHeap ? pivotsHeap.length : end);
} else {
// the element is in the right partition
begin = pivot + 1;
- node = FastMath.min(2 * node + 2, usePivotsHeap ? pivotsHeap.length : end);
+ node = AccurateMath.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/Max.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/Max.java
index 0e4f85e00..b3b7a90e4 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/Max.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/Max.java
@@ -21,7 +21,7 @@ import java.io.Serializable;
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.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Returns the maximum of the available values.
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/MedianOf3PivotingStrategy.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/MedianOf3PivotingStrategy.java
index 7d2842f40..671ccca43 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/MedianOf3PivotingStrategy.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/MedianOf3PivotingStrategy.java
@@ -19,7 +19,7 @@ package org.apache.commons.math4.legacy.stat.descriptive.rank;
import java.io.Serializable;
import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/Min.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/Min.java
index 0ce7b45d5..760ba36d3 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/Min.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/Min.java
@@ -21,7 +21,7 @@ import java.io.Serializable;
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.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Returns the minimum of the available values.
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/PSquarePercentile.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/PSquarePercentile.java
index ee06b41b3..29a54c6d5 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/PSquarePercentile.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/PSquarePercentile.java
@@ -36,7 +36,7 @@ import org.apache.commons.math4.legacy.exception.NullArgumentException;
import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
import org.apache.commons.math4.legacy.stat.descriptive.AbstractStorelessUnivariateStatistic;
import org.apache.commons.math4.legacy.stat.descriptive.StorelessUnivariateStatistic;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
import org.apache.commons.numbers.core.Precision;
/**
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 8fe9c5136..777fce6dd 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
@@ -28,8 +28,8 @@ import org.apache.commons.math4.legacy.exception.OutOfRangeException;
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.util.FastMath;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.legacy.core.MathArrays;
import org.apache.commons.numbers.core.Precision;
/**
@@ -964,7 +964,7 @@ public class Percentile extends AbstractUnivariateStatistic implements Serializa
protected double estimate(final double[] values,
final int[] pivotsHeap, final double pos,
final int length, final KthSelector selector) {
- return super.estimate(values, pivotsHeap, FastMath.ceil(pos - 0.5), length, selector);
+ return super.estimate(values, pivotsHeap, AccurateMath.ceil(pos - 0.5), length, selector);
}
@Override
public double evaluate(final double[] work, final double[] sampleWeights,
@@ -1001,9 +1001,9 @@ public class Percentile extends AbstractUnivariateStatistic implements Serializa
final int[] pivotsHeap, final double pos,
final int length, final KthSelector selector) {
final double low =
- super.estimate(values, pivotsHeap, FastMath.ceil(pos - 0.5), length, selector);
+ super.estimate(values, pivotsHeap, AccurateMath.ceil(pos - 0.5), length, selector);
final double high =
- super.estimate(values, pivotsHeap,FastMath.floor(pos + 0.5), length, selector);
+ super.estimate(values, pivotsHeap,AccurateMath.floor(pos + 0.5), length, selector);
return (low + high) / 2;
}
@Override
@@ -1025,7 +1025,7 @@ public class Percentile extends AbstractUnivariateStatistic implements Serializa
protected double index(final double p, final int length) {
final double minLimit = 1d/2 / length;
return Double.compare(p, minLimit) <= 0 ?
- 0 : FastMath.rint(length * p);
+ 0 : AccurateMath.rint(length * p);
}
@Override
public double evaluate(final double[] work, final double[] sampleWeights,
@@ -1271,7 +1271,7 @@ public class Percentile extends AbstractUnivariateStatistic implements Serializa
final double pos, final int length,
final KthSelector selector) {
- final double fpos = FastMath.floor(pos);
+ final double fpos = AccurateMath.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/rank/RandomPivotingStrategy.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/RandomPivotingStrategy.java
index 279738f9e..70efe5ff1 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/RandomPivotingStrategy.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/rank/RandomPivotingStrategy.java
@@ -21,7 +21,7 @@ import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
import org.apache.commons.rng.RestorableUniformRandomProvider;
import org.apache.commons.rng.simple.RandomSource;
import org.apache.commons.rng.core.RandomProviderDefaultState;
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 2ac140a7e..cd697fe32 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,8 +22,8 @@ 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.stat.descriptive.WeightedEvaluation;
-import org.apache.commons.math4.legacy.util.FastMath;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Returns the product of the available values.
@@ -165,7 +165,7 @@ public class Product extends AbstractStorelessUnivariateStatistic implements Ser
if (MathArrays.verifyValues(values, weights, begin, length, true)) {
product = 1.0;
for (int i = begin; i < begin + length; i++) {
- product *= FastMath.pow(values[i], weights[i]);
+ product *= AccurateMath.pow(values[i], weights[i]);
}
}
return product;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/summary/Sum.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/summary/Sum.java
index fc8b72388..ecb102bff 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/summary/Sum.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/descriptive/summary/Sum.java
@@ -21,7 +21,7 @@ import java.io.Serializable;
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.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
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 dd709eb73..1b8832a74 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 java.io.Serializable;
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.util.FastMath;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Returns the sum of the natural logs for this collection of values.
*
- * Uses {@link org.apache.commons.math4.legacy.util.FastMath#log(double)} to compute the logs.
+ * Uses {@link org.apache.commons.math4.legacy.core.jdkmath.AccurateMath#log(double)} to compute the logs.
* Therefore,
*
+ * {@code mvn test -Dtest=AccurateMathStrictComparisonTest}
+ * or just run tests against a single method (e.g. scalb):
+ * {@code mvn test -Dtest=AccurateMathStrictComparisonTest -DargLine="-DtestMethod=scalb"}
+ */
+@SuppressWarnings("boxing")
+@RunWith(Parameterized.class)
+public class AccurateMathStrictComparisonTest {
+
+ // Values which often need special handling
+ private static final Double[] DOUBLE_SPECIAL_VALUES = {
+ -0.0, +0.0, // 1,2
+ Double.NaN, // 3
+ Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, // 4,5
+ -Double.MAX_VALUE, Double.MAX_VALUE, // 6,7
+ // decreasing order of absolute value to help catch first failure
+ -Precision.EPSILON, Precision.EPSILON, // 8,9
+ -Precision.SAFE_MIN, Precision.SAFE_MIN, // 10,11
+ -Double.MIN_VALUE, Double.MIN_VALUE, // 12,13
+ };
+
+ private static final Float [] FLOAT_SPECIAL_VALUES = {
+ -0.0f, +0.0f, // 1,2
+ Float.NaN, // 3
+ Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY, // 4,5
+ Float.MIN_VALUE, Float.MAX_VALUE, // 6,7
+ -Float.MIN_VALUE, -Float.MAX_VALUE, // 8,9
+ };
+
+ private static final Object [] LONG_SPECIAL_VALUES = {
+ -1,0,1, // 1,2,3
+ Long.MIN_VALUE, Long.MAX_VALUE, // 4,5
+ };
+
+ private static final Object[] INT_SPECIAL_VALUES = {
+ -1,0,1, // 1,2,3
+ Integer.MIN_VALUE, Integer.MAX_VALUE, // 4,5
+ };
+
+ private final Method mathMethod;
+ private final Method fastMethod;
+ private final Type[] types;
+ private final Object[][] valueArrays;
+
+ public AccurateMathStrictComparisonTest(Method m, Method f, Type[] types, Object[][] data) throws Exception{
+ this.mathMethod=m;
+ this.fastMethod=f;
+ this.types=types;
+ this.valueArrays=data;
+ }
+
+ @Test
+ public void test1() throws Exception{
+ setupMethodCall(mathMethod, fastMethod, types, valueArrays);
+ }
+ private static boolean isNumber(Double d) {
+ return !(d.isInfinite() || d.isNaN());
+ }
+
+ private static boolean isNumber(Float f) {
+ return !(f.isInfinite() || f.isNaN());
+ }
+
+ private static void reportFailedResults(Method mathMethod, Object[] params, Object expected, Object actual, int[] entries){
+ final String methodName = mathMethod.getName();
+ String format = null;
+ long actL=0;
+ long expL=0;
+ if (expected instanceof Double) {
+ Double exp = (Double) expected;
+ Double act = (Double) actual;
+ if (isNumber(exp) && isNumber(act) && exp != 0) { // show difference as hex
+ actL = Double.doubleToLongBits(act);
+ expL = Double.doubleToLongBits(exp);
+ if (Math.abs(actL-expL)==1) {
+ // Not 100% sure off-by-one errors are allowed everywhere, so only allow for these methods
+ if (methodName.equals("toRadians") || methodName.equals("atan2")) {
+ return;
+ }
+ }
+ format = "%016x";
+ }
+ } else if (expected instanceof Float ){
+ Float exp = (Float) expected;
+ Float act = (Float) actual;
+ if (isNumber(exp) && isNumber(act) && exp != 0) { // show difference as hex
+ actL = Float.floatToIntBits(act);
+ expL = Float.floatToIntBits(exp);
+ format = "%08x";
+ }
+ }
+ StringBuilder sb = new StringBuilder();
+ sb.append(mathMethod.getReturnType().getSimpleName());
+ sb.append(" ");
+ sb.append(methodName);
+ sb.append("(");
+ String sep = "";
+ for(Object o : params){
+ sb.append(sep);
+ sb.append(o);
+ sep=", ";
+ }
+ sb.append(") expected ");
+ if (format != null){
+ sb.append(String.format(format, expL));
+ } else {
+ sb.append(expected);
+ }
+ sb.append(" actual ");
+ if (format != null){
+ sb.append(String.format(format, actL));
+ } else {
+ sb.append(actual);
+ }
+ sb.append(" entries ");
+ sb.append(Arrays.toString(entries));
+ String message = sb.toString();
+ final boolean fatal = true;
+ if (fatal) {
+ Assert.fail(message);
+ } else {
+ System.out.println(message);
+ }
+ }
+
+ private static void callMethods(Method mathMethod, Method fastMethod,
+ Object[] params, int[] entries) throws IllegalAccessException {
+ try {
+ Object expected;
+ try {
+ expected = mathMethod.invoke(mathMethod, params);
+ } catch (InvocationTargetException ite) {
+ expected = ite.getCause();
+ }
+ Object actual;
+ try {
+ actual = fastMethod.invoke(mathMethod, params);
+ } catch (InvocationTargetException ite) {
+ actual = ite.getCause();
+ }
+ if (expected instanceof ArithmeticException) {
+ Assert.assertEquals(MathArithmeticException.class, actual.getClass());
+ } else if (!expected.equals(actual)) {
+ reportFailedResults(mathMethod, params, expected, actual, entries);
+ }
+ } catch (IllegalArgumentException e) {
+ Assert.fail(mathMethod+" "+e);
+ }
+ }
+
+ private static void setupMethodCall(Method mathMethod, Method fastMethod,
+ Type[] types, Object[][] valueArrays) throws Exception {
+ Object[] params = new Object[types.length];
+ int entry1 = 0;
+ int[] entries = new int[types.length];
+ for(Object d : valueArrays[0]) {
+ entry1++;
+ params[0] = d;
+ entries[0] = entry1;
+ if (params.length > 1){
+ int entry2 = 0;
+ for(Object d1 : valueArrays[1]) {
+ entry2++;
+ params[1] = d1;
+ entries[1] = entry2;
+ callMethods(mathMethod, fastMethod, params, entries);
+ }
+ } else {
+ callMethods(mathMethod, fastMethod, params, entries);
+ }
+ }
+ }
+
+ @Parameters
+ public static List
- * {@code mvn test -Dtest=FastMathStrictComparisonTest}
+ * {@code mvn test -Dtest=AccurateMathStrictComparisonTest}
* or just run tests against a single method (e.g. scalb):
- * {@code mvn test -Dtest=FastMathStrictComparisonTest -DargLine="-DtestMethod=scalb"}
+ * {@code mvn test -Dtest=AccurateMathStrictComparisonTest -DargLine="-DtestMethod=scalb"}
*/
@SuppressWarnings("boxing")
@RunWith(Parameterized.class)
-public class FastMathStrictComparisonTest {
+public class AccurateMathStrictComparisonTest {
// Values which often need special handling
private static final Double[] DOUBLE_SPECIAL_VALUES = {
@@ -79,7 +79,7 @@ public class FastMathStrictComparisonTest {
private final Type[] types;
private final Object[][] valueArrays;
- public FastMathStrictComparisonTest(Method m, Method f, Type[] types, Object[][] data) throws Exception{
+ public AccurateMathStrictComparisonTest(Method m, Method f, Type[] types, Object[][] data) throws Exception{
this.mathMethod=m;
this.fastMethod=f;
this.types=types;
@@ -218,8 +218,8 @@ public class FastMathStrictComparisonTest {
Type []types = mathMethod.getGenericParameterTypes();
if (types.length >=1) { // Only check methods with at least one parameter
try {
- // Get the corresponding FastMath method
- Method fastMethod = FastMath.class.getDeclaredMethod(mathMethod.getName(), (Class[]) types);
+ // Get the corresponding AccurateMath method
+ Method fastMethod = AccurateMath.class.getDeclaredMethod(mathMethod.getName(), (Class[]) types);
if (Modifier.isPublic(fastMethod.getModifiers())) { // It must be public too
if (singleMethod != null && !fastMethod.getName().equals(singleMethod)) {
break method;
@@ -249,10 +249,10 @@ public class FastMathStrictComparisonTest {
list.add(new Object[]{mathMethod, fastMethod, types, values});
// setupMethodCall(mathMethod, fastMethod, params, data);
} else {
- System.out.println("Cannot find public FastMath method corresponding to: "+mathMethod);
+ System.out.println("Cannot find public AccurateMath method corresponding to: "+mathMethod);
}
} catch (NoSuchMethodException e) {
- System.out.println("Cannot find FastMath method corresponding to: "+mathMethod);
+ System.out.println("Cannot find AccurateMath method corresponding to: "+mathMethod);
}
}
}
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
new file mode 100644
index 000000000..6a8ff2728
--- /dev/null
+++ b/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMathTest.java
@@ -0,0 +1,1965 @@
+/*
+ * 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.legacy.core.jdkmath;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Type;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.math.RoundingMode;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import org.apache.commons.numbers.core.ArithmeticUtils;
+import org.apache.commons.numbers.core.Precision;
+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.exception.MathArithmeticException;
+import org.apache.commons.rng.UniformRandomProvider;
+import org.apache.commons.rng.simple.RandomSource;
+
+public class AccurateMathTest {
+
+ private static final double MAX_ERROR_ULP = 0.51;
+ private static final int NUMBER_OF_TRIALS = 1000;
+
+ private DfpField field;
+ private UniformRandomProvider generator;
+
+ @Before
+ public void setUp() {
+ field = new DfpField(40);
+ generator = RandomSource.create(RandomSource.MT, 6176597458463500194l);
+ }
+
+ @Test
+ public void testMinMaxDouble() {
+ double[][] pairs = {
+ { -50.0, 50.0 },
+ { Double.POSITIVE_INFINITY, 1.0 },
+ { Double.NEGATIVE_INFINITY, 1.0 },
+ { Double.NaN, 1.0 },
+ { Double.POSITIVE_INFINITY, 0.0 },
+ { Double.NEGATIVE_INFINITY, 0.0 },
+ { Double.NaN, 0.0 },
+ { Double.NaN, Double.NEGATIVE_INFINITY },
+ { Double.NaN, Double.POSITIVE_INFINITY },
+ { Precision.SAFE_MIN, Precision.EPSILON }
+ };
+ for (double[] pair : pairs) {
+ assertEquals("min(" + pair[0] + ", " + pair[1] + ")",
+ Math.min(pair[0], pair[1]),
+ AccurateMath.min(pair[0], pair[1]),
+ Precision.EPSILON);
+ assertEquals("min(" + pair[1] + ", " + pair[0] + ")",
+ Math.min(pair[1], pair[0]),
+ AccurateMath.min(pair[1], pair[0]),
+ Precision.EPSILON);
+ assertEquals("max(" + pair[0] + ", " + pair[1] + ")",
+ Math.max(pair[0], pair[1]),
+ AccurateMath.max(pair[0], pair[1]),
+ Precision.EPSILON);
+ assertEquals("max(" + pair[1] + ", " + pair[0] + ")",
+ Math.max(pair[1], pair[0]),
+ AccurateMath.max(pair[1], pair[0]),
+ Precision.EPSILON);
+ }
+ }
+
+ @Test
+ public void testMinMaxFloat() {
+ float[][] pairs = {
+ { -50.0f, 50.0f },
+ { Float.POSITIVE_INFINITY, 1.0f },
+ { Float.NEGATIVE_INFINITY, 1.0f },
+ { Float.NaN, 1.0f },
+ { Float.POSITIVE_INFINITY, 0.0f },
+ { Float.NEGATIVE_INFINITY, 0.0f },
+ { Float.NaN, 0.0f },
+ { Float.NaN, Float.NEGATIVE_INFINITY },
+ { Float.NaN, Float.POSITIVE_INFINITY }
+ };
+ for (float[] pair : pairs) {
+ assertEquals("min(" + pair[0] + ", " + pair[1] + ")",
+ Math.min(pair[0], pair[1]),
+ AccurateMath.min(pair[0], pair[1]),
+ Precision.EPSILON);
+ assertEquals("min(" + pair[1] + ", " + pair[0] + ")",
+ Math.min(pair[1], pair[0]),
+ AccurateMath.min(pair[1], pair[0]),
+ Precision.EPSILON);
+ assertEquals("max(" + pair[0] + ", " + pair[1] + ")",
+ Math.max(pair[0], pair[1]),
+ AccurateMath.max(pair[0], pair[1]),
+ Precision.EPSILON);
+ assertEquals("max(" + pair[1] + ", " + pair[0] + ")",
+ Math.max(pair[1], pair[0]),
+ AccurateMath.max(pair[1], pair[0]),
+ Precision.EPSILON);
+ }
+ }
+
+ @Test
+ public void testConstants() {
+ assertEquals(Math.PI, AccurateMath.PI, 1.0e-20);
+ assertEquals(Math.E, AccurateMath.E, 1.0e-20);
+ }
+
+ @Test
+ public void testAtan2() {
+ double y1 = 1.2713504628280707e10;
+ double x1 = -5.674940885228782e-10;
+ assertEquals(Math.atan2(y1, x1), AccurateMath.atan2(y1, x1), 2 * Precision.EPSILON);
+ double y2 = 0.0;
+ double x2 = Double.POSITIVE_INFINITY;
+ assertEquals(Math.atan2(y2, x2), AccurateMath.atan2(y2, x2), Precision.SAFE_MIN);
+ }
+
+ @Test
+ public void testHyperbolic() {
+ double maxErr = 0;
+ for (double x = -30; x < 30; x += 0.001) {
+ double tst = AccurateMath.sinh(x);
+ double ref = Math.sinh(x);
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(ref - tst) / AccurateMath.ulp(ref));
+ }
+ assertEquals(0, maxErr, 2);
+
+ maxErr = 0;
+ for (double x = -30; x < 30; x += 0.001) {
+ double tst = AccurateMath.cosh(x);
+ double ref = Math.cosh(x);
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(ref - tst) / AccurateMath.ulp(ref));
+ }
+ assertEquals(0, maxErr, 2);
+
+ maxErr = 0;
+ for (double x = -0.5; x < 0.5; x += 0.001) {
+ double tst = AccurateMath.tanh(x);
+ double ref = Math.tanh(x);
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(ref - tst) / AccurateMath.ulp(ref));
+ }
+ assertEquals(0, maxErr, 4);
+
+ }
+
+ @Test
+ public void testMath904() {
+ final double x = -1;
+ final double y = (5 + 1e-15) * 1e15;
+ assertEquals(Math.pow(x, y),
+ AccurateMath.pow(x, y), 0);
+ assertEquals(Math.pow(x, -y),
+ AccurateMath.pow(x, -y), 0);
+ }
+
+ @Test
+ public void testMath905LargePositive() {
+ final double start = StrictMath.log(Double.MAX_VALUE);
+ final double endT = StrictMath.sqrt(2) * StrictMath.sqrt(Double.MAX_VALUE);
+ final double end = 2 * StrictMath.log(endT);
+
+ double maxErr = 0;
+ for (double x = start; x < end; x += 1e-3) {
+ final double tst = AccurateMath.cosh(x);
+ final double ref = Math.cosh(x);
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(ref - tst) / AccurateMath.ulp(ref));
+ }
+ assertEquals(0, maxErr, 3);
+
+ for (double x = start; x < end; x += 1e-3) {
+ final double tst = AccurateMath.sinh(x);
+ final double ref = Math.sinh(x);
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(ref - tst) / AccurateMath.ulp(ref));
+ }
+ assertEquals(0, maxErr, 3);
+ }
+
+ @Test
+ public void testMath905LargeNegative() {
+ final double start = -StrictMath.log(Double.MAX_VALUE);
+ final double endT = StrictMath.sqrt(2) * StrictMath.sqrt(Double.MAX_VALUE);
+ final double end = -2 * StrictMath.log(endT);
+
+ double maxErr = 0;
+ for (double x = start; x > end; x -= 1e-3) {
+ final double tst = AccurateMath.cosh(x);
+ final double ref = Math.cosh(x);
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(ref - tst) / AccurateMath.ulp(ref));
+ }
+ assertEquals(0, maxErr, 3);
+
+ for (double x = start; x > end; x -= 1e-3) {
+ final double tst = AccurateMath.sinh(x);
+ final double ref = Math.sinh(x);
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(ref - tst) / AccurateMath.ulp(ref));
+ }
+ assertEquals(0, maxErr, 3);
+ }
+
+ @Test
+ public void testMath1269() {
+ final double arg = 709.8125;
+ final double vM = Math.exp(arg);
+ final double vFM = AccurateMath.exp(arg);
+ assertTrue("exp(" + arg + ") is " + vFM + " instead of " + vM,
+ Precision.equalsIncludingNaN(vM, vFM));
+ }
+
+ @Test
+ public void testHyperbolicInverses() {
+ double maxErr = 0;
+ for (double x = -30; x < 30; x += 0.01) {
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(x - AccurateMath.sinh(AccurateMath.asinh(x))) / (2 * AccurateMath.ulp(x)));
+ }
+ assertEquals(0, maxErr, 3);
+
+ maxErr = 0;
+ for (double x = 1; x < 30; x += 0.01) {
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(x - AccurateMath.cosh(AccurateMath.acosh(x))) / (2 * AccurateMath.ulp(x)));
+ }
+ assertEquals(0, maxErr, 2);
+
+ maxErr = 0;
+ for (double x = -1 + Precision.EPSILON; x < 1 - Precision.EPSILON; x += 0.0001) {
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(x - AccurateMath.tanh(AccurateMath.atanh(x))) / (2 * AccurateMath.ulp(x)));
+ }
+ assertEquals(0, maxErr, 2);
+ }
+
+ @Test
+ public void testLogAccuracy() {
+ double maxerrulp = 0.0;
+
+ for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
+ double x = Math.exp(generator.nextDouble() * 1416.0 - 708.0) * generator.nextDouble();
+ // double x = generator.nextDouble()*2.0;
+ double tst = AccurateMath.log(x);
+ double ref = DfpMath.log(field.newDfp(x)).toDouble();
+ double err = (tst - ref) / ref;
+
+ if (err != 0.0) {
+ double ulp = Math.abs(ref -
+ Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
+ double errulp = field.newDfp(tst).subtract(DfpMath.log(field.newDfp(x))).divide(field.newDfp(ulp)).toDouble();
+// System.out.println(x + "\t" + tst + "\t" + ref + "\t" + err + "\t" + errulp);
+
+ maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
+ }
+ }
+
+ assertTrue("log() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+ }
+
+ @Test
+ public void testLog10Accuracy() {
+ double maxerrulp = 0.0;
+
+ for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
+ double x = Math.exp(generator.nextDouble() * 1416.0 - 708.0) * generator.nextDouble();
+ // double x = generator.nextDouble()*2.0;
+ double tst = AccurateMath.log10(x);
+ double ref = DfpMath.log(field.newDfp(x)).divide(DfpMath.log(field.newDfp("10"))).toDouble();
+ double err = (tst - ref) / ref;
+
+ if (err != 0.0) {
+ double ulp = Math.abs(ref -
+ Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
+ double errulp = field.newDfp(tst).subtract(DfpMath.log(field.newDfp(x)).divide(DfpMath.log(field.newDfp("10")))).divide(field.newDfp(ulp)).toDouble();
+// System.out.println(x + "\t" + tst + "\t" + ref + "\t" + err + "\t" + errulp);
+
+ maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
+ }
+ }
+
+ assertTrue("log10() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+ }
+
+ @Test
+ public void testLog1pAccuracy() {
+ double maxerrulp = 0.0;
+
+ for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
+ double x = Math.exp(generator.nextDouble() * 10.0 - 5.0) * generator.nextDouble();
+ // double x = generator.nextDouble()*2.0;
+ double tst = AccurateMath.log1p(x);
+ double ref = DfpMath.log(field.newDfp(x).add(field.getOne())).toDouble();
+ double err = (tst - ref) / ref;
+
+ if (err != 0.0) {
+ double ulp = Math.abs(ref -
+ Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
+ double errulp = field.newDfp(tst).subtract(DfpMath.log(field.newDfp(x).add(field.getOne()))).divide(field.newDfp(ulp)).toDouble();
+// System.out.println(x + "\t" + tst + "\t" + ref + "\t" + err + "\t" + errulp);
+
+ maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
+ }
+ }
+
+ assertTrue("log1p() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+ }
+
+ @Test
+ public void testLog1pSpecialCases() {
+ assertTrue("Logp of -1.0 should be -Inf", Double.isInfinite(AccurateMath.log1p(-1.0)));
+ }
+
+ @Test
+ public void testLogSpecialCases() {
+ assertEquals("Log of zero should be -Inf", Double.NEGATIVE_INFINITY, AccurateMath.log(0.0), 1.0);
+ assertEquals("Log of -zero should be -Inf", Double.NEGATIVE_INFINITY, AccurateMath.log(-0.0), 1.0);
+ assertTrue("Log of NaN should be NaN", Double.isNaN(AccurateMath.log(Double.NaN)));
+ assertTrue("Log of negative number should be NaN", Double.isNaN(AccurateMath.log(-1.0)));
+ assertEquals("Log of Double.MIN_VALUE should be -744.4400719213812", -744.4400719213812, AccurateMath.log(Double.MIN_VALUE), Precision.EPSILON);
+ assertEquals("Log of infinity should be infinity", Double.POSITIVE_INFINITY, AccurateMath.log(Double.POSITIVE_INFINITY), 1.0);
+ }
+
+ @Test
+ public void testExpSpecialCases() {
+ // Smallest value that will round up to Double.MIN_VALUE
+ assertEquals(Double.MIN_VALUE, AccurateMath.exp(-745.1332191019411), Precision.EPSILON);
+ assertEquals("exp(-745.1332191019412) should be 0.0", 0.0, AccurateMath.exp(-745.1332191019412), Precision.EPSILON);
+ assertTrue("exp of NaN should be NaN", Double.isNaN(AccurateMath.exp(Double.NaN)));
+ assertEquals("exp of infinity should be infinity", Double.POSITIVE_INFINITY, AccurateMath.exp(Double.POSITIVE_INFINITY), 1.0);
+ assertEquals("exp of -infinity should be 0.0", 0.0, AccurateMath.exp(Double.NEGATIVE_INFINITY), Precision.EPSILON);
+ assertEquals("exp(1) should be Math.E", Math.E, AccurateMath.exp(1.0), Precision.EPSILON);
+ }
+
+ @Test
+ public void testPowSpecialCases() {
+ final double EXACT = -1.0;
+
+ assertEquals("pow(-1, 0) should be 1.0", 1.0, AccurateMath.pow(-1.0, 0.0), Precision.EPSILON);
+ assertEquals("pow(-1, -0) should be 1.0", 1.0, AccurateMath.pow(-1.0, -0.0), Precision.EPSILON);
+ assertEquals("pow(PI, 1.0) should be PI", AccurateMath.PI, AccurateMath.pow(AccurateMath.PI, 1.0), Precision.EPSILON);
+ assertEquals("pow(-PI, 1.0) should be -PI", -AccurateMath.PI, AccurateMath.pow(-AccurateMath.PI, 1.0), Precision.EPSILON);
+ assertTrue("pow(PI, NaN) should be NaN", Double.isNaN(AccurateMath.pow(Math.PI, Double.NaN)));
+ assertTrue("pow(NaN, PI) should be NaN", Double.isNaN(AccurateMath.pow(Double.NaN, Math.PI)));
+ assertEquals("pow(2.0, Infinity) should be Infinity", Double.POSITIVE_INFINITY, AccurateMath.pow(2.0, Double.POSITIVE_INFINITY), 1.0);
+ assertEquals("pow(0.5, -Infinity) should be Infinity", Double.POSITIVE_INFINITY, AccurateMath.pow(0.5, Double.NEGATIVE_INFINITY), 1.0);
+ assertEquals("pow(0.5, Infinity) should be 0.0", 0.0, AccurateMath.pow(0.5, Double.POSITIVE_INFINITY), Precision.EPSILON);
+ assertEquals("pow(2.0, -Infinity) should be 0.0", 0.0, AccurateMath.pow(2.0, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+ assertEquals("pow(0.0, 0.5) should be 0.0", 0.0, AccurateMath.pow(0.0, 0.5), Precision.EPSILON);
+ assertEquals("pow(Infinity, -0.5) should be 0.0", 0.0, AccurateMath.pow(Double.POSITIVE_INFINITY, -0.5), Precision.EPSILON);
+ assertEquals("pow(0.0, -0.5) should be Inf", Double.POSITIVE_INFINITY, AccurateMath.pow(0.0, -0.5), 1.0);
+ assertEquals("pow(Inf, 0.5) should be Inf", Double.POSITIVE_INFINITY, AccurateMath.pow(Double.POSITIVE_INFINITY, 0.5), 1.0);
+ assertEquals("pow(-0.0, -3.0) should be -Inf", Double.NEGATIVE_INFINITY, AccurateMath.pow(-0.0, -3.0), 1.0);
+ assertEquals("pow(-0.0, Infinity) should be 0.0", 0.0, AccurateMath.pow(-0.0, Double.POSITIVE_INFINITY), Precision.EPSILON);
+ assertTrue("pow(-0.0, NaN) should be NaN", Double.isNaN(AccurateMath.pow(-0.0, Double.NaN)));
+ assertEquals("pow(-0.0, -tiny) should be Infinity", Double.POSITIVE_INFINITY, AccurateMath.pow(-0.0, -Double.MIN_VALUE), 1.0);
+ assertEquals("pow(-0.0, -huge) should be Infinity", Double.POSITIVE_INFINITY, AccurateMath.pow(-0.0, -Double.MAX_VALUE), 1.0);
+ assertEquals("pow(-Inf, 3.0) should be -Inf", Double.NEGATIVE_INFINITY, AccurateMath.pow(Double.NEGATIVE_INFINITY, 3.0), 1.0);
+ assertEquals("pow(-Inf, -3.0) should be -0.0", -0.0, AccurateMath.pow(Double.NEGATIVE_INFINITY, -3.0), EXACT);
+ assertEquals("pow(-0.0, -3.5) should be Inf", Double.POSITIVE_INFINITY, AccurateMath.pow(-0.0, -3.5), 1.0);
+ assertEquals("pow(Inf, 3.5) should be Inf", Double.POSITIVE_INFINITY, AccurateMath.pow(Double.POSITIVE_INFINITY, 3.5), 1.0);
+ assertEquals("pow(-2.0, 3.0) should be -8.0", -8.0, AccurateMath.pow(-2.0, 3.0), Precision.EPSILON);
+ assertTrue("pow(-2.0, 3.5) should be NaN", Double.isNaN(AccurateMath.pow(-2.0, 3.5)));
+ assertTrue("pow(NaN, -Infinity) should be NaN", Double.isNaN(AccurateMath.pow(Double.NaN, Double.NEGATIVE_INFINITY)));
+ assertEquals("pow(NaN, 0.0) should be 1.0", 1.0, AccurateMath.pow(Double.NaN, 0.0), Precision.EPSILON);
+ assertEquals("pow(-Infinity, -Infinity) should be 0.0", 0.0, AccurateMath.pow(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+ assertEquals("pow(-huge, -huge) should be 0.0", 0.0, AccurateMath.pow(-Double.MAX_VALUE, -Double.MAX_VALUE), Precision.EPSILON);
+ assertTrue("pow(-huge, huge) should be +Inf", Double.isInfinite(AccurateMath.pow(-Double.MAX_VALUE, Double.MAX_VALUE)));
+ assertTrue("pow(NaN, -Infinity) should be NaN", Double.isNaN(AccurateMath.pow(Double.NaN, Double.NEGATIVE_INFINITY)));
+ assertEquals("pow(NaN, -0.0) should be 1.0", 1.0, AccurateMath.pow(Double.NaN, -0.0), Precision.EPSILON);
+ assertEquals("pow(-Infinity, -Infinity) should be 0.0", 0.0, AccurateMath.pow(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+ assertEquals("pow(-huge, -huge) should be 0.0", 0.0, AccurateMath.pow(-Double.MAX_VALUE, -Double.MAX_VALUE), Precision.EPSILON);
+ assertEquals("pow(-huge, huge) should be +Inf", Double.POSITIVE_INFINITY, AccurateMath.pow(-Double.MAX_VALUE, Double.MAX_VALUE), 1.0);
+
+ // Added tests for a 100% coverage
+
+ assertTrue("pow(+Inf, NaN) should be NaN", Double.isNaN(AccurateMath.pow(Double.POSITIVE_INFINITY, Double.NaN)));
+ assertTrue("pow(1.0, +Inf) should be NaN", Double.isNaN(AccurateMath.pow(1.0, Double.POSITIVE_INFINITY)));
+ assertTrue("pow(-Inf, NaN) should be NaN", Double.isNaN(AccurateMath.pow(Double.NEGATIVE_INFINITY, Double.NaN)));
+ assertEquals("pow(-Inf, -1.0) should be -0.0", -0.0, AccurateMath.pow(Double.NEGATIVE_INFINITY, -1.0), EXACT);
+ assertEquals("pow(-Inf, -2.0) should be 0.0", 0.0, AccurateMath.pow(Double.NEGATIVE_INFINITY, -2.0), EXACT);
+ assertEquals("pow(-Inf, 1.0) should be -Inf", Double.NEGATIVE_INFINITY, AccurateMath.pow(Double.NEGATIVE_INFINITY, 1.0), 1.0);
+ assertEquals("pow(-Inf, 2.0) should be +Inf", Double.POSITIVE_INFINITY, AccurateMath.pow(Double.NEGATIVE_INFINITY, 2.0), 1.0);
+ assertTrue("pow(1.0, -Inf) should be NaN", Double.isNaN(AccurateMath.pow(1.0, Double.NEGATIVE_INFINITY)));
+ assertEquals("pow(-0.0, 1.0) should be -0.0", -0.0, AccurateMath.pow(-0.0, 1.0), EXACT);
+ assertEquals("pow(0.0, 1.0) should be 0.0", 0.0, AccurateMath.pow(0.0, 1.0), EXACT);
+ assertEquals("pow(0.0, +Inf) should be 0.0", 0.0, AccurateMath.pow(0.0, Double.POSITIVE_INFINITY), EXACT);
+ assertEquals("pow(-0.0, even) should be 0.0", 0.0, AccurateMath.pow(-0.0, 6.0), EXACT);
+ assertEquals("pow(-0.0, odd) should be -0.0", -0.0, AccurateMath.pow(-0.0, 13.0), EXACT);
+ assertEquals("pow(-0.0, -even) should be +Inf", Double.POSITIVE_INFINITY, AccurateMath.pow(-0.0, -6.0), EXACT);
+ assertEquals("pow(-0.0, -odd) should be -Inf", Double.NEGATIVE_INFINITY, AccurateMath.pow(-0.0, -13.0), EXACT);
+ assertEquals("pow(-2.0, 4.0) should be 16.0", 16.0, AccurateMath.pow(-2.0, 4.0), EXACT);
+ assertEquals("pow(-2.0, 4.5) should be NaN", Double.NaN, AccurateMath.pow(-2.0, 4.5), EXACT);
+ assertEquals("pow(-0.0, -0.0) should be 1.0", 1.0, AccurateMath.pow(-0.0, -0.0), EXACT);
+ assertEquals("pow(-0.0, 0.0) should be 1.0", 1.0, AccurateMath.pow(-0.0, 0.0), EXACT);
+ assertEquals("pow(0.0, -0.0) should be 1.0", 1.0, AccurateMath.pow(0.0, -0.0), EXACT);
+ assertEquals("pow(0.0, 0.0) should be 1.0", 1.0, AccurateMath.pow(0.0, 0.0), EXACT);
+ }
+
+ @Test(timeout=20000L)
+ public void testPowAllSpecialCases() {
+ final double EXACT = -1.0;
+ final double DOUBLES[] = new double[]
+ {
+ Double.NEGATIVE_INFINITY, -0.0, Double.NaN, 0.0, Double.POSITIVE_INFINITY,
+ Long.MIN_VALUE, Integer.MIN_VALUE, Short.MIN_VALUE, Byte.MIN_VALUE,
+ -(double)Long.MIN_VALUE, -(double)Integer.MIN_VALUE, -(double)Short.MIN_VALUE, -(double)Byte.MIN_VALUE,
+ Byte.MAX_VALUE, Short.MAX_VALUE, Integer.MAX_VALUE, Long.MAX_VALUE,
+ -Byte.MAX_VALUE, -Short.MAX_VALUE, -Integer.MAX_VALUE, -Long.MAX_VALUE,
+ Float.MAX_VALUE, Double.MAX_VALUE, Double.MIN_VALUE, Float.MIN_VALUE,
+ -Float.MAX_VALUE, -Double.MAX_VALUE, -Double.MIN_VALUE, -Float.MIN_VALUE,
+ 0.5, 0.1, 0.2, 0.8, 1.1, 1.2, 1.5, 1.8, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 1.3, 2.2, 2.5, 2.8, 33.0, 33.1, 33.5, 33.8, 10.0, 300.0, 400.0, 500.0,
+ -0.5, -0.1, -0.2, -0.8, -1.1, -1.2, -1.5, -1.8, -1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0, -9.0, -1.3, -2.2, -2.5, -2.8, -33.0, -33.1, -33.5, -33.8, -10.0, -300.0, -400.0, -500.0
+ };
+
+ // Special cases from Math.pow javadoc:
+ // If the second argument is positive or negative zero, then the result is 1.0.
+ for (double d : DOUBLES) {
+ assertEquals(1.0, AccurateMath.pow(d, 0.0), EXACT);
+ }
+ for (double d : DOUBLES) {
+ assertEquals(1.0, AccurateMath.pow(d, -0.0), EXACT);
+ }
+ // If the second argument is 1.0, then the result is the same as the first argument.
+ for (double d : DOUBLES) {
+ assertEquals(d, AccurateMath.pow(d, 1.0), EXACT);
+ }
+ // If the second argument is NaN, then the result is NaN.
+ for (double d : DOUBLES) {
+ assertEquals(Double.NaN, AccurateMath.pow(d, Double.NaN), EXACT);
+ }
+ // If the first argument is NaN and the second argument is nonzero, then the result is NaN.
+ for (double i : DOUBLES) {
+ if (i != 0.0) {
+ assertEquals(Double.NaN, AccurateMath.pow(Double.NaN, i), EXACT);
+ }
+ }
+ // If the absolute value of the first argument is greater than 1 and the second argument is positive infinity, or
+ // the absolute value of the first argument is less than 1 and the second argument is negative infinity, then the result is positive infinity.
+ for (double d : DOUBLES) {
+ if (Math.abs(d) > 1.0) {
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(d, Double.POSITIVE_INFINITY), EXACT);
+ }
+ }
+ for (double d : DOUBLES) {
+ if (Math.abs(d) < 1.0) {
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(d, Double.NEGATIVE_INFINITY), EXACT);
+ }
+ }
+ // If the absolute value of the first argument is greater than 1 and the second argument is negative infinity, or
+ // the absolute value of the first argument is less than 1 and the second argument is positive infinity, then the result is positive zero.
+ for (double d : DOUBLES) {
+ if (Math.abs(d) > 1.0) {
+ assertEquals(0.0, AccurateMath.pow(d, Double.NEGATIVE_INFINITY), EXACT);
+ }
+ }
+ for (double d : DOUBLES) {
+ if (Math.abs(d) < 1.0) {
+ assertEquals(0.0, AccurateMath.pow(d, Double.POSITIVE_INFINITY), EXACT);
+ }
+ }
+ // If the absolute value of the first argument equals 1 and the second argument is infinite, then the result is NaN.
+ assertEquals(Double.NaN, AccurateMath.pow(1.0, Double.POSITIVE_INFINITY), EXACT);
+ assertEquals(Double.NaN, AccurateMath.pow(1.0, Double.NEGATIVE_INFINITY), EXACT);
+ assertEquals(Double.NaN, AccurateMath.pow(-1.0, Double.POSITIVE_INFINITY), EXACT);
+ assertEquals(Double.NaN, AccurateMath.pow(-1.0, Double.NEGATIVE_INFINITY), EXACT);
+ // If the first argument is positive zero and the second argument is greater than zero, or
+ // the first argument is positive infinity and the second argument is less than zero, then the result is positive zero.
+ for (double i : DOUBLES) {
+ if (i > 0.0) {
+ assertEquals(0.0, AccurateMath.pow(0.0, i), EXACT);
+ }
+ }
+ for (double i : DOUBLES) {
+ if (i < 0.0) {
+ assertEquals(0.0, AccurateMath.pow(Double.POSITIVE_INFINITY, i), EXACT);
+ }
+ }
+ // If the first argument is positive zero and the second argument is less than zero, or
+ // the first argument is positive infinity and the second argument is greater than zero, then the result is positive infinity.
+ for (double i : DOUBLES) {
+ if (i < 0.0) {
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(0.0, i), EXACT);
+ }
+ }
+ for (double i : DOUBLES) {
+ if (i > 0.0) {
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(Double.POSITIVE_INFINITY, i), EXACT);
+ }
+ }
+ // If the first argument is negative zero and the second argument is greater than zero but not a finite odd integer, or
+ // the first argument is negative infinity and the second argument is less than zero but not a finite odd integer, then the result is positive zero.
+ for (double i : DOUBLES) {
+ if (i > 0.0 && (Double.isInfinite(i) || i % 2.0 == 0.0)) {
+ assertEquals(0.0, AccurateMath.pow(-0.0, i), EXACT);
+ }
+ }
+ for (double i : DOUBLES) {
+ if (i < 0.0 && (Double.isInfinite(i) || i % 2.0 == 0.0)) {
+ assertEquals(0.0, AccurateMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+ }
+ }
+ // If the first argument is negative zero and the second argument is a positive finite odd integer, or
+ // the first argument is negative infinity and the second argument is a negative finite odd integer, then the result is negative zero.
+ for (double i : DOUBLES) {
+ if (i > 0.0 && i % 2.0 == 1.0) {
+ assertEquals(-0.0, AccurateMath.pow(-0.0, i), EXACT);
+ }
+ }
+ for (double i : DOUBLES) {
+ if (i < 0.0 && i % 2.0 == -1.0) {
+ assertEquals(-0.0, AccurateMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+ }
+ }
+ // If the first argument is negative zero and the second argument is less than zero but not a finite odd integer, or
+ // the first argument is negative infinity and the second argument is greater than zero but not a finite odd integer, then the result is positive infinity.
+ for (double i : DOUBLES) {
+ if (i > 0.0 && (Double.isInfinite(i) || i % 2.0 == 0.0)) {
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+ }
+ }
+ for (double i : DOUBLES) {
+ if (i < 0.0 && (Double.isInfinite(i) || i % 2.0 == 0.0)) {
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(-0.0, i), EXACT);
+ }
+ }
+ // If the first argument is negative zero and the second argument is a negative finite odd integer, or
+ // the first argument is negative infinity and the second argument is a positive finite odd integer, then the result is negative infinity.
+ for (double i : DOUBLES) {
+ if (i > 0.0 && i % 2.0 == 1.0) {
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+ }
+ }
+ for (double i : DOUBLES) {
+ if (i < 0.0 && i % 2.0 == -1.0) {
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.pow(-0.0, i), EXACT);
+ }
+ }
+ for (double d : DOUBLES) {
+ // If the first argument is finite and less than zero
+ if (d < 0.0 && Math.abs(d) <= Double.MAX_VALUE) {
+ for (double i : DOUBLES) {
+ if (Math.abs(i) <= Double.MAX_VALUE) {
+ // if the second argument is a finite even integer, the result is equal to the result of raising the absolute value of the first argument to the power of the second argument
+ if (i % 2.0 == 0.0) assertEquals(AccurateMath.pow(-d, i), AccurateMath.pow(d, i), EXACT);
+ // if the second argument is a finite odd integer, the result is equal to the negative of the result of raising the absolute value of the first argument to the power of the second argument
+ else if (Math.abs(i) % 2.0 == 1.0) assertEquals(-AccurateMath.pow(-d, i), AccurateMath.pow(d, i), EXACT);
+ // if the second argument is finite and not an integer, then the result is NaN.
+ else assertEquals(Double.NaN, AccurateMath.pow(d, i), EXACT);
+ }
+ }
+ }
+ }
+ // If both arguments are integers, then the result is exactly equal to the mathematical result of raising the first argument to the power
+ // of the second argument if that result can in fact be represented exactly as a double value.
+ final int TOO_BIG_TO_CALCULATE = 18; // This value is empirical: 2^18 > 200.000 resulting bits after raising d to power i.
+ for (double d : DOUBLES) {
+ if (d % 1.0 == 0.0) {
+ boolean dNegative = Double.doubleToRawLongBits( d ) < 0L;
+ for (double i : DOUBLES) {
+ if (i % 1.0 == 0.0) {
+ BigInteger bd = BigDecimal.valueOf(d).toBigInteger().abs();
+ BigInteger bi = BigDecimal.valueOf(i).toBigInteger().abs();
+ double expected;
+ if (bd.bitLength() > 1 && bi.bitLength() > 1 && 32 - Integer.numberOfLeadingZeros(bd.bitLength()) + bi.bitLength() > TOO_BIG_TO_CALCULATE) {
+ // Result would be too big.
+ expected = i < 0.0 ? 0.0 : Double.POSITIVE_INFINITY;
+ } else {
+ BigInteger res = ArithmeticUtils.pow(bd, bi);
+ if (i >= 0.0) {
+ expected = res.doubleValue();
+ } else if (res.signum() == 0) {
+ expected = Double.POSITIVE_INFINITY;
+ } else {
+ expected = BigDecimal.ONE.divide( new BigDecimal( res ), 1024, RoundingMode.HALF_UP ).doubleValue();
+ }
+ }
+ if (dNegative && bi.testBit( 0 )) {
+ expected = -expected;
+ }
+ assertEquals(d + "^" + i + "=" + expected + ", Math.pow=" + Math.pow(d, i), expected, AccurateMath.pow(d, i), expected == 0.0 || Double.isInfinite(expected) || Double.isNaN(expected) ? EXACT : 2.0 * Math.ulp(expected));
+ }
+ }
+ }
+ }
+ }
+
+ @Test
+ public void testPowLargeIntegralDouble() {
+ double y = AccurateMath.scalb(1.0, 65);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(AccurateMath.nextUp(1.0), y), 1.0);
+ assertEquals(1.0, AccurateMath.pow(1.0, y), 1.0);
+ assertEquals(0.0, AccurateMath.pow(AccurateMath.nextDown(1.0), y), 1.0);
+ assertEquals(0.0, AccurateMath.pow(AccurateMath.nextUp(-1.0), y), 1.0);
+ assertEquals(1.0, AccurateMath.pow(-1.0, y), 1.0);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(AccurateMath.nextDown(-1.0), y), 1.0);
+ }
+
+ @Test
+ public void testAtan2SpecialCases() {
+
+ assertTrue("atan2(NaN, 0.0) should be NaN", Double.isNaN(AccurateMath.atan2(Double.NaN, 0.0)));
+ assertTrue("atan2(0.0, NaN) should be NaN", Double.isNaN(AccurateMath.atan2(0.0, Double.NaN)));
+ assertEquals("atan2(0.0, 0.0) should be 0.0", 0.0, AccurateMath.atan2(0.0, 0.0), Precision.EPSILON);
+ assertEquals("atan2(0.0, 0.001) should be 0.0", 0.0, AccurateMath.atan2(0.0, 0.001), Precision.EPSILON);
+ assertEquals("atan2(0.1, +Inf) should be 0.0", 0.0, AccurateMath.atan2(0.1, Double.POSITIVE_INFINITY), Precision.EPSILON);
+ assertEquals("atan2(-0.0, 0.0) should be -0.0", -0.0, AccurateMath.atan2(-0.0, 0.0), Precision.EPSILON);
+ assertEquals("atan2(-0.0, 0.001) should be -0.0", -0.0, AccurateMath.atan2(-0.0, 0.001), Precision.EPSILON);
+ assertEquals("atan2(-0.0, +Inf) should be -0.0", -0.0, AccurateMath.atan2(-0.1, Double.POSITIVE_INFINITY), Precision.EPSILON);
+ assertEquals("atan2(0.0, -0.0) should be PI", AccurateMath.PI, AccurateMath.atan2(0.0, -0.0), Precision.EPSILON);
+ assertEquals("atan2(0.1, -Inf) should be PI", AccurateMath.PI, AccurateMath.atan2(0.1, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+ assertEquals("atan2(-0.0, -0.0) should be -PI", -AccurateMath.PI, AccurateMath.atan2(-0.0, -0.0), Precision.EPSILON);
+ assertEquals("atan2(0.1, -Inf) should be -PI", -AccurateMath.PI, AccurateMath.atan2(-0.1, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+ assertEquals("atan2(0.1, 0.0) should be PI/2", AccurateMath.PI / 2.0, AccurateMath.atan2(0.1, 0.0), Precision.EPSILON);
+ assertEquals("atan2(0.1, -0.0) should be PI/2", AccurateMath.PI / 2.0, AccurateMath.atan2(0.1, -0.0), Precision.EPSILON);
+ assertEquals("atan2(Inf, 0.1) should be PI/2", AccurateMath.PI / 2.0, AccurateMath.atan2(Double.POSITIVE_INFINITY, 0.1), Precision.EPSILON);
+ assertEquals("atan2(Inf, -0.1) should be PI/2", AccurateMath.PI / 2.0, AccurateMath.atan2(Double.POSITIVE_INFINITY, -0.1), Precision.EPSILON);
+ assertEquals("atan2(-0.1, 0.0) should be -PI/2", -AccurateMath.PI / 2.0, AccurateMath.atan2(-0.1, 0.0), Precision.EPSILON);
+ assertEquals("atan2(-0.1, -0.0) should be -PI/2", -AccurateMath.PI / 2.0, AccurateMath.atan2(-0.1, -0.0), Precision.EPSILON);
+ assertEquals("atan2(-Inf, 0.1) should be -PI/2", -AccurateMath.PI / 2.0, AccurateMath.atan2(Double.NEGATIVE_INFINITY, 0.1), Precision.EPSILON);
+ assertEquals("atan2(-Inf, -0.1) should be -PI/2", -AccurateMath.PI / 2.0, AccurateMath.atan2(Double.NEGATIVE_INFINITY, -0.1), Precision.EPSILON);
+ assertEquals("atan2(Inf, Inf) should be PI/4", AccurateMath.PI / 4.0, AccurateMath.atan2(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY),
+ Precision.EPSILON);
+ assertEquals("atan2(Inf, -Inf) should be PI * 3/4", AccurateMath.PI * 3.0 / 4.0,
+ AccurateMath.atan2(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+ assertEquals("atan2(-Inf, Inf) should be -PI/4", -AccurateMath.PI / 4.0, AccurateMath.atan2(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY),
+ Precision.EPSILON);
+ assertEquals("atan2(-Inf, -Inf) should be -PI * 3/4", - AccurateMath.PI * 3.0 / 4.0,
+ AccurateMath.atan2(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+ }
+
+ @Test
+ public void testPowAccuracy() {
+ double maxerrulp = 0.0;
+
+ for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
+ double x = (generator.nextDouble() * 2.0 + 0.25);
+ double y = (generator.nextDouble() * 1200.0 - 600.0) * generator.nextDouble();
+ /*
+ * double x = AccurateMath.floor(generator.nextDouble()*1024.0 - 512.0); double
+ * y; if (x != 0) y = AccurateMath.floor(512.0 / AccurateMath.abs(x)); else
+ * y = generator.nextDouble()*1200.0; y = y - y/2; x = AccurateMath.pow(2.0, x) *
+ * generator.nextDouble(); y = y * generator.nextDouble();
+ */
+
+ // double x = generator.nextDouble()*2.0;
+ double tst = AccurateMath.pow(x, y);
+ double ref = DfpMath.pow(field.newDfp(x), field.newDfp(y)).toDouble();
+ double err = (tst - ref) / ref;
+
+ if (err != 0) {
+ double ulp = Math.abs(ref -
+ Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
+ double errulp = field.newDfp(tst).subtract(DfpMath.pow(field.newDfp(x), field.newDfp(y))).divide(field.newDfp(ulp)).toDouble();
+// System.out.println(x + "\t" + y + "\t" + tst + "\t" + ref + "\t" + err + "\t" + errulp);
+
+ maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
+ }
+ }
+
+ assertTrue("pow() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+ }
+
+ @Test
+ public void testExpAccuracy() {
+ double maxerrulp = 0.0;
+
+ for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
+ /* double x = 1.0 + i/1024.0/2.0; */
+ double x = ((generator.nextDouble() * 1416.0) - 708.0) * generator.nextDouble();
+ // double x = (generator.nextDouble() * 20.0) - 10.0;
+ // double x = ((generator.nextDouble() * 2.0) - 1.0) * generator.nextDouble();
+ /* double x = 3.0 / 512.0 * i - 3.0; */
+ double tst = AccurateMath.exp(x);
+ double ref = DfpMath.exp(field.newDfp(x)).toDouble();
+ double err = (tst - ref) / ref;
+
+ if (err != 0) {
+ double ulp = Math.abs(ref -
+ Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
+ double errulp = field.newDfp(tst).subtract(DfpMath.exp(field.newDfp(x))).divide(field.newDfp(ulp)).toDouble();
+// System.out.println(x + "\t" + tst + "\t" + ref + "\t" + err + "\t" + errulp);
+
+ maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
+ }
+ }
+
+ assertTrue("exp() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+ }
+
+ @Test
+ public void testSinAccuracy() {
+ double maxerrulp = 0.0;
+
+ for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
+ /* double x = 1.0 + i/1024.0/2.0; */
+ // double x = ((generator.nextDouble() * 1416.0) - 708.0) * generator.nextDouble();
+ double x = ((generator.nextDouble() * Math.PI) - Math.PI / 2.0) *
+ Math.pow(2, 21) * generator.nextDouble();
+ // double x = (generator.nextDouble() * 20.0) - 10.0;
+ // double x = ((generator.nextDouble() * 2.0) - 1.0) * generator.nextDouble();
+ /* double x = 3.0 / 512.0 * i - 3.0; */
+ double tst = AccurateMath.sin(x);
+ double ref = DfpMath.sin(field.newDfp(x)).toDouble();
+ double err = (tst - ref) / ref;
+
+ if (err != 0) {
+ double ulp = Math.abs(ref -
+ Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
+ double errulp = field.newDfp(tst).subtract(DfpMath.sin(field.newDfp(x))).divide(field.newDfp(ulp)).toDouble();
+// System.out.println(x + "\t" + tst + "\t" + ref + "\t" + err + "\t" + errulp);
+
+ maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
+ }
+ }
+
+ assertTrue("sin() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+ }
+
+ @Test
+ public void testCosAccuracy() {
+ double maxerrulp = 0.0;
+
+ for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
+ /* double x = 1.0 + i/1024.0/2.0; */
+ // double x = ((generator.nextDouble() * 1416.0) - 708.0) * generator.nextDouble();
+ double x = ((generator.nextDouble() * Math.PI) - Math.PI / 2.0) *
+ Math.pow(2, 21) * generator.nextDouble();
+ // double x = (generator.nextDouble() * 20.0) - 10.0;
+ // double x = ((generator.nextDouble() * 2.0) - 1.0) * generator.nextDouble();
+ /* double x = 3.0 / 512.0 * i - 3.0; */
+ double tst = AccurateMath.cos(x);
+ double ref = DfpMath.cos(field.newDfp(x)).toDouble();
+ double err = (tst - ref) / ref;
+
+ if (err != 0) {
+ double ulp = Math.abs(ref -
+ Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
+ double errulp = field.newDfp(tst).subtract(DfpMath.cos(field.newDfp(x))).divide(field.newDfp(ulp)).toDouble();
+// System.out.println(x + "\t" + tst + "\t" + ref + "\t" + err + "\t" + errulp);
+
+ maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
+ }
+ }
+
+ assertTrue("cos() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+ }
+
+ @Test
+ public void testTanAccuracy() {
+ double maxerrulp = 0.0;
+
+ for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
+ /* double x = 1.0 + i/1024.0/2.0; */
+ // double x = ((generator.nextDouble() * 1416.0) - 708.0) * generator.nextDouble();
+ double x = ((generator.nextDouble() * Math.PI) - Math.PI / 2.0) *
+ Math.pow(2, 12) * generator.nextDouble();
+ // double x = (generator.nextDouble() * 20.0) - 10.0;
+ // double x = ((generator.nextDouble() * 2.0) - 1.0) * generator.nextDouble();
+ /* double x = 3.0 / 512.0 * i - 3.0; */
+ double tst = AccurateMath.tan(x);
+ double ref = DfpMath.tan(field.newDfp(x)).toDouble();
+ double err = (tst - ref) / ref;
+
+ if (err != 0) {
+ double ulp = Math.abs(ref -
+ Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
+ double errulp = field.newDfp(tst).subtract(DfpMath.tan(field.newDfp(x))).divide(field.newDfp(ulp)).toDouble();
+// System.out.println(x + "\t" + tst + "\t" + ref + "\t" + err + "\t" + errulp);
+
+ maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
+ }
+ }
+
+ assertTrue("tan() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+ }
+
+ @Test
+ public void testAtanAccuracy() {
+ double maxerrulp = 0.0;
+
+ for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
+ /* double x = 1.0 + i/1024.0/2.0; */
+ // double x = ((generator.nextDouble() * 1416.0) - 708.0) * generator.nextDouble();
+ // double x = ((generator.nextDouble() * Math.PI) - Math.PI/2.0) *
+ // generator.nextDouble();
+ double x = ((generator.nextDouble() * 16.0) - 8.0) * generator.nextDouble();
+
+ // double x = (generator.nextDouble() * 20.0) - 10.0;
+ // double x = ((generator.nextDouble() * 2.0) - 1.0) * generator.nextDouble();
+ /* double x = 3.0 / 512.0 * i - 3.0; */
+ double tst = AccurateMath.atan(x);
+ double ref = DfpMath.atan(field.newDfp(x)).toDouble();
+ double err = (tst - ref) / ref;
+
+ if (err != 0) {
+ double ulp = Math.abs(ref -
+ Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
+ double errulp = field.newDfp(tst).subtract(DfpMath.atan(field.newDfp(x))).divide(field.newDfp(ulp)).toDouble();
+// System.out.println(x + "\t" + tst + "\t" + ref + "\t" + err + "\t" + errulp);
+
+ maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
+ }
+ }
+
+ assertTrue("atan() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+ }
+
+ @Test
+ public void testAtan2Accuracy() {
+ double maxerrulp = 0.0;
+
+ for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
+ /* double x = 1.0 + i/1024.0/2.0; */
+ // double x = ((generator.nextDouble() * 1416.0) - 708.0) * generator.nextDouble();
+ double x = generator.nextDouble() - 0.5;
+ double y = generator.nextDouble() - 0.5;
+ // double x = (generator.nextDouble() * 20.0) - 10.0;
+ // double x = ((generator.nextDouble() * 2.0) - 1.0) * generator.nextDouble();
+ /* double x = 3.0 / 512.0 * i - 3.0; */
+ double tst = AccurateMath.atan2(y, x);
+ Dfp refdfp = DfpMath.atan(field.newDfp(y).divide(field.newDfp(x)));
+ /* Make adjustments for sign */
+ if (x < 0.0) {
+ if (y > 0.0) {
+ refdfp = field.getPi().add(refdfp);
+ } else {
+ refdfp = refdfp.subtract(field.getPi());
+ }
+ }
+
+ double ref = refdfp.toDouble();
+ double err = (tst - ref) / ref;
+
+ if (err != 0) {
+ double ulp = Math.abs(ref -
+ Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
+ double errulp = field.newDfp(tst).subtract(refdfp).divide(field.newDfp(ulp)).toDouble();
+// System.out.println(x + "\t" + y + "\t" + tst + "\t" + ref + "\t" + errulp);
+
+ maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
+ }
+ }
+
+ assertTrue("atan2() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+ }
+
+ @Test
+ public void testExpm1Accuracy() {
+ double maxerrulp = 0.0;
+
+ for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
+ /* double x = 1.0 + i/1024.0/2.0; */
+ // double x = (generator.nextDouble() * 20.0) - 10.0;
+ double x = ((generator.nextDouble() * 16.0) - 8.0) * generator.nextDouble();
+ /* double x = 3.0 / 512.0 * i - 3.0; */
+ double tst = AccurateMath.expm1(x);
+ double ref = DfpMath.exp(field.newDfp(x)).subtract(field.getOne()).toDouble();
+ double err = (tst - ref) / ref;
+
+ if (err != 0) {
+ double ulp = Math.abs(ref -
+ Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
+ double errulp = field.newDfp(tst).subtract(DfpMath.exp(field.newDfp(x)).subtract(field.getOne())).divide(field.newDfp(ulp)).toDouble();
+// System.out.println(x + "\t" + tst + "\t" + ref + "\t" + err + "\t" + errulp);
+
+ maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
+ }
+ }
+
+ assertTrue("expm1() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+ }
+
+ @Test
+ public void testAsinAccuracy() {
+ double maxerrulp = 0.0;
+
+ for (int i=0; i<10000; i++) {
+ double x = ((generator.nextDouble() * 2.0) - 1.0) * generator.nextDouble();
+
+ double tst = AccurateMath.asin(x);
+ double ref = DfpMath.asin(field.newDfp(x)).toDouble();
+ double err = (tst - ref) / ref;
+
+ if (err != 0) {
+ double ulp = Math.abs(ref - Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
+ double errulp = field.newDfp(tst).subtract(DfpMath.asin(field.newDfp(x))).divide(field.newDfp(ulp)).toDouble();
+ //System.out.println(x+"\t"+tst+"\t"+ref+"\t"+err+"\t"+errulp);
+
+ maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
+ }
+ }
+
+ assertTrue("asin() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+ }
+
+ @Test
+ public void testAcosAccuracy() {
+ double maxerrulp = 0.0;
+
+ for (int i=0; i<10000; i++) {
+ double x = ((generator.nextDouble() * 2.0) - 1.0) * generator.nextDouble();
+
+ double tst = AccurateMath.acos(x);
+ double ref = DfpMath.acos(field.newDfp(x)).toDouble();
+ double err = (tst - ref) / ref;
+
+ if (err != 0) {
+ double ulp = Math.abs(ref - Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
+ double errulp = field.newDfp(tst).subtract(DfpMath.acos(field.newDfp(x))).divide(field.newDfp(ulp)).toDouble();
+ //System.out.println(x+"\t"+tst+"\t"+ref+"\t"+err+"\t"+errulp);
+
+ maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
+ }
+ }
+
+ assertTrue("acos() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+ }
+
+ /**
+ * Added tests for a 100% coverage of acos().
+ */
+ @Test
+ public void testAcosSpecialCases() {
+
+ assertTrue("acos(NaN) should be NaN", Double.isNaN(AccurateMath.acos(Double.NaN)));
+ assertTrue("acos(-1.1) should be NaN", Double.isNaN(AccurateMath.acos(-1.1)));
+ assertTrue("acos(-1.1) should be NaN", Double.isNaN(AccurateMath.acos(1.1)));
+ assertEquals("acos(-1.0) should be PI", AccurateMath.acos(-1.0), AccurateMath.PI, Precision.EPSILON);
+ assertEquals("acos(1.0) should be 0.0", AccurateMath.acos(1.0), 0.0, Precision.EPSILON);
+ assertEquals("acos(0.0) should be PI/2", AccurateMath.acos(0.0), AccurateMath.PI / 2.0, Precision.EPSILON);
+ }
+
+ /**
+ * Added tests for a 100% coverage of asin().
+ */
+ @Test
+ public void testAsinSpecialCases() {
+
+ assertTrue("asin(NaN) should be NaN", Double.isNaN(AccurateMath.asin(Double.NaN)));
+ assertTrue("asin(1.1) should be NaN", Double.isNaN(AccurateMath.asin(1.1)));
+ assertTrue("asin(-1.1) should be NaN", Double.isNaN(AccurateMath.asin(-1.1)));
+ assertEquals("asin(1.0) should be PI/2", AccurateMath.asin(1.0), AccurateMath.PI / 2.0, Precision.EPSILON);
+ assertEquals("asin(-1.0) should be -PI/2", AccurateMath.asin(-1.0), -AccurateMath.PI / 2.0, Precision.EPSILON);
+ assertEquals("asin(0.0) should be 0.0", AccurateMath.asin(0.0), 0.0, Precision.EPSILON);
+ }
+
+ private Dfp cosh(Dfp x) {
+ return DfpMath.exp(x).add(DfpMath.exp(x.negate())).divide(2);
+ }
+
+ private Dfp sinh(Dfp x) {
+ return DfpMath.exp(x).subtract(DfpMath.exp(x.negate())).divide(2);
+ }
+
+ private Dfp tanh(Dfp x) {
+ return sinh(x).divide(cosh(x));
+ }
+
+ @Test
+ public void testSinhAccuracy() {
+ double maxerrulp = 0.0;
+
+ for (int i=0; i<10000; i++) {
+ double x = ((generator.nextDouble() * 16.0) - 8.0) * generator.nextDouble();
+
+ double tst = AccurateMath.sinh(x);
+ double ref = sinh(field.newDfp(x)).toDouble();
+ double err = (tst - ref) / ref;
+
+ if (err != 0) {
+ double ulp = Math.abs(ref - Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
+ double errulp = field.newDfp(tst).subtract(sinh(field.newDfp(x))).divide(field.newDfp(ulp)).toDouble();
+ //System.out.println(x+"\t"+tst+"\t"+ref+"\t"+err+"\t"+errulp);
+ maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
+ }
+ }
+
+ assertTrue("sinh() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+ }
+
+ @Test
+ public void testCoshAccuracy() {
+ double maxerrulp = 0.0;
+
+ for (int i=0; i<10000; i++) {
+ double x = ((generator.nextDouble() * 16.0) - 8.0) * generator.nextDouble();
+
+ double tst = AccurateMath.cosh(x);
+ double ref = cosh(field.newDfp(x)).toDouble();
+ double err = (tst - ref) / ref;
+
+ if (err != 0) {
+ double ulp = Math.abs(ref - Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
+ double errulp = field.newDfp(tst).subtract(cosh(field.newDfp(x))).divide(field.newDfp(ulp)).toDouble();
+ //System.out.println(x+"\t"+tst+"\t"+ref+"\t"+err+"\t"+errulp);
+ maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
+ }
+ }
+
+ assertTrue("cosh() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+ }
+
+ @Test
+ public void testTanhAccuracy() {
+ double maxerrulp = 0.0;
+
+ for (int i=0; i<10000; i++) {
+ double x = ((generator.nextDouble() * 16.0) - 8.0) * generator.nextDouble();
+
+ double tst = AccurateMath.tanh(x);
+ double ref = tanh(field.newDfp(x)).toDouble();
+ double err = (tst - ref) / ref;
+
+ if (err != 0) {
+ double ulp = Math.abs(ref - Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
+ double errulp = field.newDfp(tst).subtract(tanh(field.newDfp(x))).divide(field.newDfp(ulp)).toDouble();
+ //System.out.println(x+"\t"+tst+"\t"+ref+"\t"+err+"\t"+errulp);
+ maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
+ }
+ }
+
+ assertTrue("tanh() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+ }
+
+ @Test
+ public void testCbrtAccuracy() {
+ double maxerrulp = 0.0;
+
+ for (int i=0; i<10000; i++) {
+ double x = ((generator.nextDouble() * 200.0) - 100.0) * generator.nextDouble();
+
+ double tst = AccurateMath.cbrt(x);
+ double ref = cbrt(field.newDfp(x)).toDouble();
+ double err = (tst - ref) / ref;
+
+ if (err != 0) {
+ double ulp = Math.abs(ref - Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
+ double errulp = field.newDfp(tst).subtract(cbrt(field.newDfp(x))).divide(field.newDfp(ulp)).toDouble();
+ //System.out.println(x+"\t"+tst+"\t"+ref+"\t"+err+"\t"+errulp);
+ maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
+ }
+ }
+
+ assertTrue("cbrt() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+ }
+
+ private Dfp cbrt(Dfp x) {
+ boolean negative=false;
+
+ if (x.lessThan(field.getZero())) {
+ negative = true;
+ x = x.negate();
+ }
+
+ Dfp y = DfpMath.pow(x, field.getOne().divide(3));
+
+ if (negative) {
+ y = y.negate();
+ }
+
+ return y;
+ }
+
+ @Test
+ public void testToDegrees() {
+ double maxerrulp = 0.0;
+ for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
+ double x = generator.nextDouble();
+ double tst = field.newDfp(x).multiply(180).divide(field.getPi()).toDouble();
+ double ref = AccurateMath.toDegrees(x);
+ double err = (tst - ref) / ref;
+
+ if (err != 0) {
+ double ulp = Math.abs(ref -
+ Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
+ double errulp = field.newDfp(tst).subtract(DfpMath.exp(field.newDfp(x)).subtract(field.getOne())).divide(field.newDfp(ulp)).toDouble();
+// System.out.println(x + "\t" + tst + "\t" + ref + "\t" + err + "\t" + errulp);
+
+ maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
+ }
+ }
+ assertTrue("toDegrees() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+ }
+
+ @Test
+ public void testToRadians() {
+ double maxerrulp = 0.0;
+ for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
+ double x = generator.nextDouble();
+ double tst = field.newDfp(x).multiply(field.getPi()).divide(180).toDouble();
+ double ref = AccurateMath.toRadians(x);
+ double err = (tst - ref) / ref;
+
+ if (err != 0) {
+ double ulp = Math.abs(ref -
+ Double.longBitsToDouble((Double.doubleToLongBits(ref) ^ 1)));
+ double errulp = field.newDfp(tst).subtract(DfpMath.exp(field.newDfp(x)).subtract(field.getOne())).divide(field.newDfp(ulp)).toDouble();
+// System.out.println(x + "\t" + tst + "\t" + ref + "\t" + err + "\t" + errulp);
+
+ maxerrulp = Math.max(maxerrulp, Math.abs(errulp));
+ }
+ }
+
+ assertTrue("toRadians() had errors in excess of " + MAX_ERROR_ULP + " ULP", maxerrulp < MAX_ERROR_ULP);
+ }
+
+ @Test
+ public void testNextAfter() {
+ // 0x402fffffffffffff 0x404123456789abcd -> 4030000000000000
+ assertEquals(16.0, AccurateMath.nextUp(15.999999999999998), 0.0);
+
+ // 0xc02fffffffffffff 0x404123456789abcd -> c02ffffffffffffe
+ assertEquals(-15.999999999999996, AccurateMath.nextAfter(-15.999999999999998, 34.27555555555555), 0.0);
+
+ // 0x402fffffffffffff 0x400123456789abcd -> 402ffffffffffffe
+ assertEquals(15.999999999999996, AccurateMath.nextDown(15.999999999999998), 0.0);
+
+ // 0xc02fffffffffffff 0x400123456789abcd -> c02ffffffffffffe
+ assertEquals(-15.999999999999996, AccurateMath.nextAfter(-15.999999999999998, 2.142222222222222), 0.0);
+
+ // 0x4020000000000000 0x404123456789abcd -> 4020000000000001
+ assertEquals(8.000000000000002, AccurateMath.nextAfter(8.0, 34.27555555555555), 0.0);
+
+ // 0xc020000000000000 0x404123456789abcd -> c01fffffffffffff
+ assertEquals(-7.999999999999999, AccurateMath.nextAfter(-8.0, 34.27555555555555), 0.0);
+
+ // 0x4020000000000000 0x400123456789abcd -> 401fffffffffffff
+ assertEquals(7.999999999999999, AccurateMath.nextAfter(8.0, 2.142222222222222), 0.0);
+
+ // 0xc020000000000000 0x400123456789abcd -> c01fffffffffffff
+ assertEquals(-7.999999999999999, AccurateMath.nextAfter(-8.0, 2.142222222222222), 0.0);
+
+ // 0x3f2e43753d36a223 0x3f2e43753d36a224 -> 3f2e43753d36a224
+ assertEquals(2.308922399667661E-4, AccurateMath.nextAfter(2.3089223996676606E-4, 2.308922399667661E-4), 0.0);
+
+ // 0x3f2e43753d36a223 0x3f2e43753d36a223 -> 3f2e43753d36a223
+ assertEquals(2.3089223996676606E-4, AccurateMath.nextAfter(2.3089223996676606E-4, 2.3089223996676606E-4), 0.0);
+
+ // 0x3f2e43753d36a223 0x3f2e43753d36a222 -> 3f2e43753d36a222
+ assertEquals(2.3089223996676603E-4, AccurateMath.nextAfter(2.3089223996676606E-4, 2.3089223996676603E-4), 0.0);
+
+ // 0x3f2e43753d36a223 0xbf2e43753d36a224 -> 3f2e43753d36a222
+ assertEquals(2.3089223996676603E-4, AccurateMath.nextAfter(2.3089223996676606E-4, -2.308922399667661E-4), 0.0);
+
+ // 0x3f2e43753d36a223 0xbf2e43753d36a223 -> 3f2e43753d36a222
+ assertEquals(2.3089223996676603E-4, AccurateMath.nextAfter(2.3089223996676606E-4, -2.3089223996676606E-4), 0.0);
+
+ // 0x3f2e43753d36a223 0xbf2e43753d36a222 -> 3f2e43753d36a222
+ assertEquals(2.3089223996676603E-4, AccurateMath.nextAfter(2.3089223996676606E-4, -2.3089223996676603E-4), 0.0);
+
+ // 0xbf2e43753d36a223 0x3f2e43753d36a224 -> bf2e43753d36a222
+ assertEquals(-2.3089223996676603E-4, AccurateMath.nextAfter(-2.3089223996676606E-4, 2.308922399667661E-4), 0.0);
+
+ // 0xbf2e43753d36a223 0x3f2e43753d36a223 -> bf2e43753d36a222
+ assertEquals(-2.3089223996676603E-4, AccurateMath.nextAfter(-2.3089223996676606E-4, 2.3089223996676606E-4), 0.0);
+
+ // 0xbf2e43753d36a223 0x3f2e43753d36a222 -> bf2e43753d36a222
+ assertEquals(-2.3089223996676603E-4, AccurateMath.nextAfter(-2.3089223996676606E-4, 2.3089223996676603E-4), 0.0);
+
+ // 0xbf2e43753d36a223 0xbf2e43753d36a224 -> bf2e43753d36a224
+ assertEquals(-2.308922399667661E-4, AccurateMath.nextAfter(-2.3089223996676606E-4, -2.308922399667661E-4), 0.0);
+
+ // 0xbf2e43753d36a223 0xbf2e43753d36a223 -> bf2e43753d36a223
+ assertEquals(-2.3089223996676606E-4, AccurateMath.nextAfter(-2.3089223996676606E-4, -2.3089223996676606E-4), 0.0);
+
+ // 0xbf2e43753d36a223 0xbf2e43753d36a222 -> bf2e43753d36a222
+ assertEquals(-2.3089223996676603E-4, AccurateMath.nextAfter(-2.3089223996676606E-4, -2.3089223996676603E-4), 0.0);
+
+ }
+
+ @Test
+ public void testDoubleNextAfterSpecialCases() {
+ assertEquals(-Double.MAX_VALUE,AccurateMath.nextAfter(Double.NEGATIVE_INFINITY, 0D), 0D);
+ assertEquals(Double.MAX_VALUE,AccurateMath.nextAfter(Double.POSITIVE_INFINITY, 0D), 0D);
+ assertEquals(Double.NaN,AccurateMath.nextAfter(Double.NaN, 0D), 0D);
+ assertEquals(Double.POSITIVE_INFINITY,AccurateMath.nextAfter(Double.MAX_VALUE, Double.POSITIVE_INFINITY), 0D);
+ assertEquals(Double.NEGATIVE_INFINITY,AccurateMath.nextAfter(-Double.MAX_VALUE, Double.NEGATIVE_INFINITY), 0D);
+ assertEquals(Double.MIN_VALUE, AccurateMath.nextAfter(0D, 1D), 0D);
+ assertEquals(-Double.MIN_VALUE, AccurateMath.nextAfter(0D, -1D), 0D);
+ assertEquals(0D, AccurateMath.nextAfter(Double.MIN_VALUE, -1), 0D);
+ assertEquals(0D, AccurateMath.nextAfter(-Double.MIN_VALUE, 1), 0D);
+ }
+
+ @Test
+ public void testFloatNextAfterSpecialCases() {
+ assertEquals(-Float.MAX_VALUE, AccurateMath.nextAfter(Float.NEGATIVE_INFINITY, 0F), 0F);
+ assertEquals(Float.MAX_VALUE, AccurateMath.nextAfter(Float.POSITIVE_INFINITY, 0F), 0F);
+ assertEquals(Float.NaN, AccurateMath.nextAfter(Float.NaN, 0F), 0F);
+ assertEquals(Float.POSITIVE_INFINITY, AccurateMath.nextUp(Float.MAX_VALUE), 0F);
+ assertEquals(Float.NEGATIVE_INFINITY, AccurateMath.nextDown(-Float.MAX_VALUE), 0F);
+ assertEquals(Float.MIN_VALUE, AccurateMath.nextAfter(0F, 1F), 0F);
+ assertEquals(-Float.MIN_VALUE, AccurateMath.nextAfter(0F, -1F), 0F);
+ assertEquals(0F, AccurateMath.nextAfter(Float.MIN_VALUE, -1F), 0F);
+ assertEquals(0F, AccurateMath.nextAfter(-Float.MIN_VALUE, 1F), 0F);
+ }
+
+ @Test
+ public void testDoubleScalbSpecialCases() {
+ assertEquals(2.5269841324701218E-175, AccurateMath.scalb(2.2250738585072014E-308, 442), 0D);
+ assertEquals(1.307993905256674E297, AccurateMath.scalb(1.1102230246251565E-16, 1040), 0D);
+ assertEquals(7.2520887996488946E-217, AccurateMath.scalb(Double.MIN_VALUE, 356), 0D);
+ assertEquals(8.98846567431158E307, AccurateMath.scalb(Double.MIN_VALUE, 2097), 0D);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.scalb(Double.MIN_VALUE, 2098), 0D);
+ assertEquals(1.1125369292536007E-308, AccurateMath.scalb(2.225073858507201E-308, -1), 0D);
+ assertEquals(1.0E-323, AccurateMath.scalb(Double.MAX_VALUE, -2097), 0D);
+ assertEquals(Double.MIN_VALUE, AccurateMath.scalb(Double.MAX_VALUE, -2098), 0D);
+ assertEquals(0, AccurateMath.scalb(Double.MAX_VALUE, -2099), 0D);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.scalb(Double.POSITIVE_INFINITY, -1000000), 0D);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.scalb(-1.1102230246251565E-16, 1078), 0D);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.scalb(-1.1102230246251565E-16, 1079), 0D);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.scalb(-2.2250738585072014E-308, 2047), 0D);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.scalb(-2.2250738585072014E-308, 2048), 0D);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.scalb(-1.7976931348623157E308, 2147483647), 0D);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.scalb( 1.7976931348623157E308, 2147483647), 0D);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.scalb(-1.1102230246251565E-16, 2147483647), 0D);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.scalb( 1.1102230246251565E-16, 2147483647), 0D);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.scalb(-2.2250738585072014E-308, 2147483647), 0D);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.scalb( 2.2250738585072014E-308, 2147483647), 0D);
+ }
+
+ @Test
+ public void testFloatScalbSpecialCases() {
+ assertEquals(0f, AccurateMath.scalb(Float.MIN_VALUE, -30), 0F);
+ assertEquals(2 * Float.MIN_VALUE, AccurateMath.scalb(Float.MIN_VALUE, 1), 0F);
+ assertEquals(7.555786e22f, AccurateMath.scalb(Float.MAX_VALUE, -52), 0F);
+ assertEquals(1.7014118e38f, AccurateMath.scalb(Float.MIN_VALUE, 276), 0F);
+ assertEquals(Float.POSITIVE_INFINITY, AccurateMath.scalb(Float.MIN_VALUE, 277), 0F);
+ assertEquals(5.8774718e-39f, AccurateMath.scalb(1.1754944e-38f, -1), 0F);
+ assertEquals(2 * Float.MIN_VALUE, AccurateMath.scalb(Float.MAX_VALUE, -276), 0F);
+ assertEquals(Float.MIN_VALUE, AccurateMath.scalb(Float.MAX_VALUE, -277), 0F);
+ assertEquals(0, AccurateMath.scalb(Float.MAX_VALUE, -278), 0F);
+ assertEquals(Float.POSITIVE_INFINITY, AccurateMath.scalb(Float.POSITIVE_INFINITY, -1000000), 0F);
+ assertEquals(-3.13994498e38f, AccurateMath.scalb(-1.1e-7f, 151), 0F);
+ assertEquals(Float.NEGATIVE_INFINITY, AccurateMath.scalb(-1.1e-7f, 152), 0F);
+ assertEquals(Float.POSITIVE_INFINITY, AccurateMath.scalb(3.4028235E38f, 2147483647), 0F);
+ assertEquals(Float.NEGATIVE_INFINITY, AccurateMath.scalb(-3.4028235E38f, 2147483647), 0F);
+ }
+
+ private boolean compareClassMethods(Class class1, Class class2){
+ boolean allfound = true;
+ for(Method method1 : class1.getDeclaredMethods()){
+ if (Modifier.isPublic(method1.getModifiers())){
+ Type []params = method1.getGenericParameterTypes();
+ try {
+ class2.getDeclaredMethod(method1.getName(), (Class[]) params);
+ } catch (NoSuchMethodException e) {
+ allfound = false;
+ System.out.println(class2.getSimpleName()+" does not implement: "+method1);
+ }
+ }
+ }
+ return allfound;
+ }
+
+ @Test
+ public void checkMissingAccurateMathClasses() {
+ boolean ok = compareClassMethods(StrictMath.class, AccurateMath.class);
+ assertTrue("AccurateMath should implement all StrictMath methods", ok);
+ }
+
+ @Ignore
+ @Test
+ public void checkExtraAccurateMathClasses() {
+ compareClassMethods(AccurateMath.class, StrictMath.class);
+ }
+
+ @Test
+ public void testSignumDouble() {
+ final double delta = 0.0;
+ assertEquals(1.0, AccurateMath.signum(2.0), delta);
+ assertEquals(0.0, AccurateMath.signum(0.0), delta);
+ assertEquals(-1.0, AccurateMath.signum(-2.0), delta);
+ Assert.assertTrue(Double.isNaN(AccurateMath.signum(Double.NaN)));
+ }
+
+ @Test
+ public void testSignumFloat() {
+ final float delta = 0.0F;
+ assertEquals(1.0F, AccurateMath.signum(2.0F), delta);
+ assertEquals(0.0F, AccurateMath.signum(0.0F), delta);
+ assertEquals(-1.0F, AccurateMath.signum(-2.0F), delta);
+ Assert.assertTrue(Double.isNaN(AccurateMath.signum(Float.NaN)));
+ }
+
+ @Test
+ public void testLogWithBase() {
+ assertEquals(2.0, AccurateMath.log(2, 4), 0);
+ assertEquals(3.0, AccurateMath.log(2, 8), 0);
+ assertTrue(Double.isNaN(AccurateMath.log(-1, 1)));
+ assertTrue(Double.isNaN(AccurateMath.log(1, -1)));
+ assertTrue(Double.isNaN(AccurateMath.log(0, 0)));
+ assertEquals(0, AccurateMath.log(0, 10), 0);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.log(10, 0), 0);
+ }
+
+ @Test
+ public void testIndicatorDouble() {
+ double delta = 0.0;
+ assertEquals(1.0, AccurateMath.copySign(1d, 2.0), delta);
+ assertEquals(1.0, AccurateMath.copySign(1d, 0.0), delta);
+ assertEquals(-1.0, AccurateMath.copySign(1d, -0.0), delta);
+ assertEquals(1.0, AccurateMath.copySign(1d, Double.POSITIVE_INFINITY), delta);
+ assertEquals(-1.0, AccurateMath.copySign(1d, Double.NEGATIVE_INFINITY), delta);
+ assertEquals(1.0, AccurateMath.copySign(1d, Double.NaN), delta);
+ assertEquals(-1.0, AccurateMath.copySign(1d, -2.0), delta);
+ }
+
+ @Test
+ public void testIndicatorFloat() {
+ float delta = 0.0F;
+ assertEquals(1.0F, AccurateMath.copySign(1d, 2.0F), delta);
+ assertEquals(1.0F, AccurateMath.copySign(1d, 0.0F), delta);
+ assertEquals(-1.0F, AccurateMath.copySign(1d, -0.0F), delta);
+ assertEquals(1.0F, AccurateMath.copySign(1d, Float.POSITIVE_INFINITY), delta);
+ assertEquals(-1.0F, AccurateMath.copySign(1d, Float.NEGATIVE_INFINITY), delta);
+ assertEquals(1.0F, AccurateMath.copySign(1d, Float.NaN), delta);
+ assertEquals(-1.0F, AccurateMath.copySign(1d, -2.0F), delta);
+ }
+
+ @Test
+ public void testIntPow() {
+ final int maxExp = 300;
+ DfpField field = new DfpField(40);
+ final double base = 1.23456789;
+ Dfp baseDfp = field.newDfp(base);
+ Dfp dfpPower = field.getOne();
+ for (int i = 0; i < maxExp; i++) {
+ assertEquals("exp=" + i, dfpPower.toDouble(), AccurateMath.pow(base, i),
+ 0.6 * AccurateMath.ulp(dfpPower.toDouble()));
+ dfpPower = dfpPower.multiply(baseDfp);
+ }
+ }
+
+ @Test
+ public void testIntPowHuge() {
+ assertTrue(Double.isInfinite(AccurateMath.pow(AccurateMath.scalb(1.0, 500), 4)));
+ }
+
+ @Test(timeout=5000L) // This test must finish in finite time.
+ public void testIntPowLongMinValue() {
+ assertEquals(1.0, AccurateMath.pow(1.0, Long.MIN_VALUE), -1.0);
+ }
+
+ @Test(timeout=5000L)
+ public void testIntPowSpecialCases() {
+ final double EXACT = -1.0;
+ final double DOUBLES[] = new double[]
+ {
+ Double.NEGATIVE_INFINITY, -0.0, Double.NaN, 0.0, Double.POSITIVE_INFINITY,
+ Long.MIN_VALUE, Integer.MIN_VALUE, Short.MIN_VALUE, Byte.MIN_VALUE,
+ -(double)Long.MIN_VALUE, -(double)Integer.MIN_VALUE, -(double)Short.MIN_VALUE, -(double)Byte.MIN_VALUE,
+ Byte.MAX_VALUE, Short.MAX_VALUE, Integer.MAX_VALUE, Long.MAX_VALUE,
+ -Byte.MAX_VALUE, -Short.MAX_VALUE, -Integer.MAX_VALUE, -Long.MAX_VALUE,
+ Float.MAX_VALUE, Double.MAX_VALUE, Double.MIN_VALUE, Float.MIN_VALUE,
+ -Float.MAX_VALUE, -Double.MAX_VALUE, -Double.MIN_VALUE, -Float.MIN_VALUE,
+ 0.5, 0.1, 0.2, 0.8, 1.1, 1.2, 1.5, 1.8, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 1.3, 2.2, 2.5, 2.8, 33.0, 33.1, 33.5, 33.8, 10.0, 300.0, 400.0, 500.0,
+ -0.5, -0.1, -0.2, -0.8, -1.1, -1.2, -1.5, -1.8, -1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0, -9.0, -1.3, -2.2, -2.5, -2.8, -33.0, -33.1, -33.5, -33.8, -10.0, -300.0, -400.0, -500.0
+ };
+
+ final long INTS[] = new long[]{Long.MAX_VALUE, Long.MAX_VALUE - 1, Long.MIN_VALUE, Long.MIN_VALUE + 1, Long.MIN_VALUE + 2, Integer.MAX_VALUE, Integer.MAX_VALUE - 1, Integer.MIN_VALUE, Integer.MIN_VALUE + 1, Integer.MIN_VALUE + 2, 0, 1, 2, 3, 5, 8, 10, 20, 100, 300, 500, -1, -2, -3, -5, -8, -10, -20, -100, -300, -500};
+ // Special cases from Math.pow javadoc:
+ // If the second argument is positive or negative zero, then the result is 1.0.
+ for (double d : DOUBLES) {
+ assertEquals(1.0, AccurateMath.pow(d, 0L), EXACT);
+ }
+ // If the second argument is 1.0, then the result is the same as the first argument.
+ for (double d : DOUBLES) {
+ assertEquals(d, AccurateMath.pow(d, 1L), EXACT);
+ }
+ // If the second argument is NaN, then the result is NaN. <- Impossible with int.
+ // If the first argument is NaN and the second argument is nonzero, then the result is NaN.
+ for (long i : INTS) {
+ if (i != 0L) {
+ assertEquals(Double.NaN, AccurateMath.pow(Double.NaN, i), EXACT);
+ }
+ }
+ // If the absolute value of the first argument is greater than 1 and the second argument is positive infinity, or
+ // the absolute value of the first argument is less than 1 and the second argument is negative infinity, then the result is positive infinity.
+ for (double d : DOUBLES) {
+ if (Math.abs(d) > 1.0) {
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(d, Long.MAX_VALUE - 1L), EXACT);
+ }
+ }
+ for (double d : DOUBLES) {
+ if (Math.abs(d) < 1.0) {
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(d, Long.MIN_VALUE), EXACT);
+ }
+ }
+ // Note: Long.MAX_VALUE isn't actually an infinity, so its parity affects the sign of resulting infinity.
+ for (double d : DOUBLES) {
+ if (Math.abs(d) > 1.0) {
+ assertTrue(Double.isInfinite(AccurateMath.pow(d, Long.MAX_VALUE)));
+ }
+ }
+ for (double d : DOUBLES) {
+ if (Math.abs(d) < 1.0) {
+ assertTrue(Double.isInfinite(AccurateMath.pow(d, Long.MIN_VALUE + 1L)));
+ }
+ }
+ // If the absolute value of the first argument is greater than 1 and the second argument is negative infinity, or
+ // the absolute value of the first argument is less than 1 and the second argument is positive infinity, then the result is positive zero.
+ for (double d : DOUBLES) {
+ if (Math.abs(d) > 1.0) {
+ assertEquals(0.0, AccurateMath.pow(d, Long.MIN_VALUE), EXACT);
+ }
+ }
+ for (double d : DOUBLES) {
+ if (Math.abs(d) < 1.0) {
+ assertEquals(0.0, AccurateMath.pow(d, Long.MAX_VALUE - 1L), EXACT);
+ }
+ }
+ // Note: Long.MAX_VALUE isn't actually an infinity, so its parity affects the sign of resulting zero.
+ for (double d : DOUBLES) {
+ if (Math.abs(d) > 1.0) {
+ assertTrue(AccurateMath.pow(d, Long.MIN_VALUE + 1L) == 0.0);
+ }
+ }
+ for (double d : DOUBLES) {
+ if (Math.abs(d) < 1.0) {
+ assertTrue(AccurateMath.pow(d, Long.MAX_VALUE) == 0.0);
+ }
+ }
+ // If the absolute value of the first argument equals 1 and the second argument is infinite, then the result is NaN. <- Impossible with int.
+ // If the first argument is positive zero and the second argument is greater than zero, or
+ // the first argument is positive infinity and the second argument is less than zero, then the result is positive zero.
+ for (long i : INTS) {
+ if (i > 0L) {
+ assertEquals(0.0, AccurateMath.pow(0.0, i), EXACT);
+ }
+ }
+ for (long i : INTS) {
+ if (i < 0L) {
+ assertEquals(0.0, AccurateMath.pow(Double.POSITIVE_INFINITY, i), EXACT);
+ }
+ }
+ // If the first argument is positive zero and the second argument is less than zero, or
+ // the first argument is positive infinity and the second argument is greater than zero, then the result is positive infinity.
+ for (long i : INTS) {
+ if (i < 0L) {
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(0.0, i), EXACT);
+ }
+ }
+ for (long i : INTS) {
+ if (i > 0L) {
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(Double.POSITIVE_INFINITY, i), EXACT);
+ }
+ }
+ // If the first argument is negative zero and the second argument is greater than zero but not a finite odd integer, or
+ // the first argument is negative infinity and the second argument is less than zero but not a finite odd integer, then the result is positive zero.
+ for (long i : INTS) {
+ if (i > 0L && (i & 1L) == 0L) {
+ assertEquals(0.0, AccurateMath.pow(-0.0, i), EXACT);
+ }
+ }
+ for (long i : INTS) {
+ if (i < 0L && (i & 1L) == 0L) {
+ assertEquals(0.0, AccurateMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+ }
+ }
+ // If the first argument is negative zero and the second argument is a positive finite odd integer, or
+ // the first argument is negative infinity and the second argument is a negative finite odd integer, then the result is negative zero.
+ for (long i : INTS) {
+ if (i > 0L && (i & 1L) == 1L) {
+ assertEquals(-0.0, AccurateMath.pow(-0.0, i), EXACT);
+ }
+ }
+ for (long i : INTS) {
+ if (i < 0L && (i & 1L) == 1L) {
+ assertEquals(-0.0, AccurateMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+ }
+ }
+ // If the first argument is negative zero and the second argument is less than zero but not a finite odd integer, or
+ // the first argument is negative infinity and the second argument is greater than zero but not a finite odd integer, then the result is positive infinity.
+ for (long i : INTS) {
+ if (i > 0L && (i & 1L) == 0L) {
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+ }
+ }
+ for (long i : INTS) {
+ if (i < 0L && (i & 1L) == 0L) {
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(-0.0, i), EXACT);
+ }
+ }
+ // If the first argument is negative zero and the second argument is a negative finite odd integer, or
+ // the first argument is negative infinity and the second argument is a positive finite odd integer, then the result is negative infinity.
+ for (long i : INTS) {
+ if (i > 0L && (i & 1L) == 1L) {
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+ }
+ }
+ for (long i : INTS) {
+ if (i < 0L && (i & 1L) == 1L) {
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.pow(-0.0, i), EXACT);
+ }
+ }
+ for (double d : DOUBLES) {
+ // If the first argument is finite and less than zero
+ if (d < 0.0 && Math.abs(d) <= Double.MAX_VALUE) {
+ for (long i : INTS) {
+ // if the second argument is a finite even integer, the result is equal to the result of raising the absolute value of the first argument to the power of the second argument
+ if ((i & 1L) == 0L) assertEquals(AccurateMath.pow(-d, i), AccurateMath.pow(d, i), EXACT);
+ // if the second argument is a finite odd integer, the result is equal to the negative of the result of raising the absolute value of the first argument to the power of the second argument
+ else assertEquals(-AccurateMath.pow(-d, i), AccurateMath.pow(d, i), EXACT);
+ // if the second argument is finite and not an integer, then the result is NaN. <- Impossible with int.
+ }
+ }
+ }
+ // If both arguments are integers, then the result is exactly equal to the mathematical result of raising the first argument to the power
+ // of the second argument if that result can in fact be represented exactly as a double value. <- Other tests.
+ }
+
+ @Test
+ public void testIncrementExactInt() {
+ int[] specialValues = new int[] {
+ Integer.MIN_VALUE, Integer.MIN_VALUE + 1, Integer.MIN_VALUE + 2,
+ Integer.MAX_VALUE, Integer.MAX_VALUE - 1, Integer.MAX_VALUE - 2,
+ -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ -1 - (Integer.MIN_VALUE / 2), 0 - (Integer.MIN_VALUE / 2), 1 - (Integer.MIN_VALUE / 2),
+ -1 + (Integer.MAX_VALUE / 2), 0 + (Integer.MAX_VALUE / 2), 1 + (Integer.MAX_VALUE / 2),
+ };
+ for (int a : specialValues) {
+ BigInteger bdA = BigInteger.valueOf(a);
+ BigInteger bdSum = bdA.add(BigInteger.ONE);
+ if (bdSum.compareTo(BigInteger.valueOf(Integer.MIN_VALUE)) < 0 ||
+ bdSum.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) > 0) {
+ try {
+ AccurateMath.incrementExact(a);
+ Assert.fail("an exception should have been thrown");
+ } catch (MathArithmeticException mae) {
+ // expected
+ }
+ } else {
+ assertEquals(bdSum, BigInteger.valueOf(AccurateMath.incrementExact(a)));
+ }
+ }
+ }
+
+ @Test
+ public void testDecrementExactInt() {
+ int[] specialValues = new int[] {
+ Integer.MIN_VALUE, Integer.MIN_VALUE + 1, Integer.MIN_VALUE + 2,
+ Integer.MAX_VALUE, Integer.MAX_VALUE - 1, Integer.MAX_VALUE - 2,
+ -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ -1 - (Integer.MIN_VALUE / 2), 0 - (Integer.MIN_VALUE / 2), 1 - (Integer.MIN_VALUE / 2),
+ -1 + (Integer.MAX_VALUE / 2), 0 + (Integer.MAX_VALUE / 2), 1 + (Integer.MAX_VALUE / 2),
+ };
+ for (int a : specialValues) {
+ BigInteger bdA = BigInteger.valueOf(a);
+ BigInteger bdSub = bdA.subtract(BigInteger.ONE);
+ if (bdSub.compareTo(BigInteger.valueOf(Integer.MIN_VALUE)) < 0 ||
+ bdSub.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) > 0) {
+ try {
+ AccurateMath.decrementExact(a);
+ fail("an exception should have been thrown");
+ } catch (MathArithmeticException mae) {
+ // expected
+ }
+ } else {
+ assertEquals(bdSub, BigInteger.valueOf(AccurateMath.decrementExact(a)));
+ }
+ }
+ }
+
+ @Test
+ public void testAddExactInt() {
+ int[] specialValues = new int[] {
+ Integer.MIN_VALUE, Integer.MIN_VALUE + 1, Integer.MIN_VALUE + 2,
+ Integer.MAX_VALUE, Integer.MAX_VALUE - 1, Integer.MAX_VALUE - 2,
+ -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ -1 - (Integer.MIN_VALUE / 2), 0 - (Integer.MIN_VALUE / 2), 1 - (Integer.MIN_VALUE / 2),
+ -1 + (Integer.MAX_VALUE / 2), 0 + (Integer.MAX_VALUE / 2), 1 + (Integer.MAX_VALUE / 2),
+ };
+ for (int a : specialValues) {
+ for (int b : specialValues) {
+ BigInteger bdA = BigInteger.valueOf(a);
+ BigInteger bdB = BigInteger.valueOf(b);
+ BigInteger bdSum = bdA.add(bdB);
+ if (bdSum.compareTo(BigInteger.valueOf(Integer.MIN_VALUE)) < 0 ||
+ bdSum.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) > 0) {
+ try {
+ AccurateMath.addExact(a, b);
+ fail("an exception should have been thrown");
+ } catch (MathArithmeticException mae) {
+ // expected
+ }
+ } else {
+ assertEquals(bdSum, BigInteger.valueOf(AccurateMath.addExact(a, b)));
+ }
+ }
+ }
+ }
+
+ @Test
+ public void testAddExactLong() {
+ long[] specialValues = new long[] {
+ Long.MIN_VALUE, Long.MIN_VALUE + 1, Long.MIN_VALUE + 2,
+ Long.MAX_VALUE, Long.MAX_VALUE - 1, Long.MAX_VALUE - 2,
+ -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ -1 - (Long.MIN_VALUE / 2), 0 - (Long.MIN_VALUE / 2), 1 - (Long.MIN_VALUE / 2),
+ -1 + (Long.MAX_VALUE / 2), 0 + (Long.MAX_VALUE / 2), 1 + (Long.MAX_VALUE / 2),
+ };
+ for (long a : specialValues) {
+ for (long b : specialValues) {
+ BigInteger bdA = BigInteger.valueOf(a);
+ BigInteger bdB = BigInteger.valueOf(b);
+ BigInteger bdSum = bdA.add(bdB);
+ if (bdSum.compareTo(BigInteger.valueOf(Long.MIN_VALUE)) < 0 ||
+ bdSum.compareTo(BigInteger.valueOf(Long.MAX_VALUE)) > 0) {
+ try {
+ AccurateMath.addExact(a, b);
+ fail("an exception should have been thrown");
+ } catch (MathArithmeticException mae) {
+ // expected
+ }
+ } else {
+ assertEquals(bdSum, BigInteger.valueOf(AccurateMath.addExact(a, b)));
+ }
+ }
+ }
+ }
+
+ @Test
+ public void testSubtractExactInt() {
+ int[] specialValues = new int[] {
+ Integer.MIN_VALUE, Integer.MIN_VALUE + 1, Integer.MIN_VALUE + 2,
+ Integer.MAX_VALUE, Integer.MAX_VALUE - 1, Integer.MAX_VALUE - 2,
+ -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ -1 - (Integer.MIN_VALUE / 2), 0 - (Integer.MIN_VALUE / 2), 1 - (Integer.MIN_VALUE / 2),
+ -1 + (Integer.MAX_VALUE / 2), 0 + (Integer.MAX_VALUE / 2), 1 + (Integer.MAX_VALUE / 2),
+ };
+ for (int a : specialValues) {
+ for (int b : specialValues) {
+ BigInteger bdA = BigInteger.valueOf(a);
+ BigInteger bdB = BigInteger.valueOf(b);
+ BigInteger bdSub = bdA.subtract(bdB);
+ if (bdSub.compareTo(BigInteger.valueOf(Integer.MIN_VALUE)) < 0 ||
+ bdSub.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) > 0) {
+ try {
+ AccurateMath.subtractExact(a, b);
+ fail("an exception should have been thrown");
+ } catch (MathArithmeticException mae) {
+ // expected
+ }
+ } else {
+ assertEquals(bdSub, BigInteger.valueOf(AccurateMath.subtractExact(a, b)));
+ }
+ }
+ }
+ }
+
+ @Test
+ public void testSubtractExactLong() {
+ long[] specialValues = new long[] {
+ Long.MIN_VALUE, Long.MIN_VALUE + 1, Long.MIN_VALUE + 2,
+ Long.MAX_VALUE, Long.MAX_VALUE - 1, Long.MAX_VALUE - 2,
+ -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ -1 - (Long.MIN_VALUE / 2), 0 - (Long.MIN_VALUE / 2), 1 - (Long.MIN_VALUE / 2),
+ -1 + (Long.MAX_VALUE / 2), 0 + (Long.MAX_VALUE / 2), 1 + (Long.MAX_VALUE / 2),
+ };
+ for (long a : specialValues) {
+ for (long b : specialValues) {
+ BigInteger bdA = BigInteger.valueOf(a);
+ BigInteger bdB = BigInteger.valueOf(b);
+ BigInteger bdSub = bdA.subtract(bdB);
+ if (bdSub.compareTo(BigInteger.valueOf(Long.MIN_VALUE)) < 0 ||
+ bdSub.compareTo(BigInteger.valueOf(Long.MAX_VALUE)) > 0) {
+ try {
+ AccurateMath.subtractExact(a, b);
+ fail("an exception should have been thrown");
+ } catch (MathArithmeticException mae) {
+ // expected
+ }
+ } else {
+ assertEquals(bdSub, BigInteger.valueOf(AccurateMath.subtractExact(a, b)));
+ }
+ }
+ }
+ }
+
+ @Test
+ public void testMultiplyExactInt() {
+ int[] specialValues = new int[] {
+ Integer.MIN_VALUE, Integer.MIN_VALUE + 1, Integer.MIN_VALUE + 2,
+ Integer.MAX_VALUE, Integer.MAX_VALUE - 1, Integer.MAX_VALUE - 2,
+ -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ -1 - (Integer.MIN_VALUE / 2), 0 - (Integer.MIN_VALUE / 2), 1 - (Integer.MIN_VALUE / 2),
+ -1 + (Integer.MAX_VALUE / 2), 0 + (Integer.MAX_VALUE / 2), 1 + (Integer.MAX_VALUE / 2),
+ };
+ for (int a : specialValues) {
+ for (int b : specialValues) {
+ BigInteger bdA = BigInteger.valueOf(a);
+ BigInteger bdB = BigInteger.valueOf(b);
+ BigInteger bdMul = bdA.multiply(bdB);
+ if (bdMul.compareTo(BigInteger.valueOf(Integer.MIN_VALUE)) < 0 ||
+ bdMul.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) > 0) {
+ try {
+ AccurateMath.multiplyExact(a, b);
+ fail("an exception should have been thrown " + a + b);
+ } catch (MathArithmeticException mae) {
+ // expected
+ }
+ } else {
+ assertEquals(bdMul, BigInteger.valueOf(AccurateMath.multiplyExact(a, b)));
+ }
+ }
+ }
+ }
+
+ @Test
+ public void testMultiplyExactLong() {
+ long[] specialValues = new long[] {
+ Long.MIN_VALUE, Long.MIN_VALUE + 1, Long.MIN_VALUE + 2,
+ Long.MAX_VALUE, Long.MAX_VALUE - 1, Long.MAX_VALUE - 2,
+ -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ -1 - (Long.MIN_VALUE / 2), 0 - (Long.MIN_VALUE / 2), 1 - (Long.MIN_VALUE / 2),
+ -1 + (Long.MAX_VALUE / 2), 0 + (Long.MAX_VALUE / 2), 1 + (Long.MAX_VALUE / 2),
+ };
+ for (long a : specialValues) {
+ for (long b : specialValues) {
+ BigInteger bdA = BigInteger.valueOf(a);
+ BigInteger bdB = BigInteger.valueOf(b);
+ BigInteger bdMul = bdA.multiply(bdB);
+ if (bdMul.compareTo(BigInteger.valueOf(Long.MIN_VALUE)) < 0 ||
+ bdMul.compareTo(BigInteger.valueOf(Long.MAX_VALUE)) > 0) {
+ try {
+ AccurateMath.multiplyExact(a, b);
+ fail("an exception should have been thrown " + a + b);
+ } catch (MathArithmeticException mae) {
+ // expected
+ }
+ } else {
+ assertEquals(bdMul, BigInteger.valueOf(AccurateMath.multiplyExact(a, b)));
+ }
+ }
+ }
+ }
+
+ @Test(expected=MathArithmeticException.class)
+ public void testToIntExactTooLow() {
+ AccurateMath.toIntExact(-1l + Integer.MIN_VALUE);
+ }
+
+ @Test(expected=MathArithmeticException.class)
+ public void testToIntExactTooHigh() {
+ AccurateMath.toIntExact(+1l + Integer.MAX_VALUE);
+ }
+
+ @Test
+ public void testToIntExact() {
+ for (int n = -1000; n < 1000; ++n) {
+ assertEquals(n, AccurateMath.toIntExact(0l + n));
+ }
+ assertEquals(Integer.MIN_VALUE, AccurateMath.toIntExact(0l + Integer.MIN_VALUE));
+ assertEquals(Integer.MAX_VALUE, AccurateMath.toIntExact(0l + Integer.MAX_VALUE));
+ }
+
+ @Test
+ public void testFloorDivInt() {
+ assertEquals(+1, AccurateMath.floorDiv(+4, +3));
+ assertEquals(-2, AccurateMath.floorDiv(-4, +3));
+ assertEquals(-2, AccurateMath.floorDiv(+4, -3));
+ assertEquals(+1, AccurateMath.floorDiv(-4, -3));
+ try {
+ AccurateMath.floorDiv(1, 0);
+ fail("an exception should have been thrown");
+ } catch (MathArithmeticException mae) {
+ // expected
+ }
+ for (int a = -100; a <= 100; ++a) {
+ for (int b = -100; b <= 100; ++b) {
+ if (b != 0) {
+ assertEquals(poorManFloorDiv(a, b), AccurateMath.floorDiv(a, b));
+ }
+ }
+ }
+ }
+
+ @Test
+ public void testFloorModInt() {
+ assertEquals(+1, AccurateMath.floorMod(+4, +3));
+ assertEquals(+2, AccurateMath.floorMod(-4, +3));
+ assertEquals(-2, AccurateMath.floorMod(+4, -3));
+ assertEquals(-1, AccurateMath.floorMod(-4, -3));
+ try {
+ AccurateMath.floorMod(1, 0);
+ fail("an exception should have been thrown");
+ } catch (MathArithmeticException mae) {
+ // expected
+ }
+ for (int a = -100; a <= 100; ++a) {
+ for (int b = -100; b <= 100; ++b) {
+ if (b != 0) {
+ assertEquals(poorManFloorMod(a, b), AccurateMath.floorMod(a, b));
+ }
+ }
+ }
+ }
+
+ @Test
+ public void testFloorDivModInt() {
+ UniformRandomProvider generator = RandomSource.create(RandomSource.WELL_1024_A,
+ 0x7ccab45edeaab90al);
+ for (int i = 0; i < 10000; ++i) {
+ int a = generator.nextInt();
+ int b = generator.nextInt();
+ if (b == 0) {
+ try {
+ AccurateMath.floorDiv(a, b);
+ fail("an exception should have been thrown");
+ } catch (MathArithmeticException mae) {
+ // expected
+ }
+ } else {
+ int d = AccurateMath.floorDiv(a, b);
+ int m = AccurateMath.floorMod(a, b);
+ assertEquals(AccurateMath.toIntExact(poorManFloorDiv(a, b)), d);
+ assertEquals(AccurateMath.toIntExact(poorManFloorMod(a, b)), m);
+ assertEquals(a, d * b + m);
+ if (b < 0) {
+ assertTrue(m <= 0);
+ assertTrue(-m < -b);
+ } else {
+ assertTrue(m >= 0);
+ assertTrue(m < b);
+ }
+ }
+ }
+ }
+
+ @Test
+ public void testFloorDivLong() {
+ assertEquals(+1l, AccurateMath.floorDiv(+4l, +3l));
+ assertEquals(-2l, AccurateMath.floorDiv(-4l, +3l));
+ assertEquals(-2l, AccurateMath.floorDiv(+4l, -3l));
+ assertEquals(+1l, AccurateMath.floorDiv(-4l, -3l));
+ try {
+ AccurateMath.floorDiv(1l, 0l);
+ fail("an exception should have been thrown");
+ } catch (MathArithmeticException mae) {
+ // expected
+ }
+ for (long a = -100l; a <= 100l; ++a) {
+ for (long b = -100l; b <= 100l; ++b) {
+ if (b != 0) {
+ assertEquals(poorManFloorDiv(a, b), AccurateMath.floorDiv(a, b));
+ }
+ }
+ }
+ }
+
+ @Test
+ public void testFloorModLong() {
+ assertEquals(+1l, AccurateMath.floorMod(+4l, +3l));
+ assertEquals(+2l, AccurateMath.floorMod(-4l, +3l));
+ assertEquals(-2l, AccurateMath.floorMod(+4l, -3l));
+ assertEquals(-1l, AccurateMath.floorMod(-4l, -3l));
+ try {
+ AccurateMath.floorMod(1l, 0l);
+ fail("an exception should have been thrown");
+ } catch (MathArithmeticException mae) {
+ // expected
+ }
+ for (long a = -100l; a <= 100l; ++a) {
+ for (long b = -100l; b <= 100l; ++b) {
+ if (b != 0) {
+ assertEquals(poorManFloorMod(a, b), AccurateMath.floorMod(a, b));
+ }
+ }
+ }
+ }
+
+ @Test
+ public void testFloorDivModLong() {
+ UniformRandomProvider generator = RandomSource.create(RandomSource.WELL_1024_A,
+ 0xb87b9bc14c96ccd5l);
+ for (int i = 0; i < 10000; ++i) {
+ long a = generator.nextLong();
+ long b = generator.nextLong();
+ if (b == 0) {
+ try {
+ AccurateMath.floorDiv(a, b);
+ fail("an exception should have been thrown");
+ } catch (MathArithmeticException mae) {
+ // expected
+ }
+ } else {
+ long d = AccurateMath.floorDiv(a, b);
+ long m = AccurateMath.floorMod(a, b);
+ assertEquals(poorManFloorDiv(a, b), d);
+ assertEquals(poorManFloorMod(a, b), m);
+ assertEquals(a, d * b + m);
+ if (b < 0) {
+ assertTrue(m <= 0);
+ assertTrue(-m < -b);
+ } else {
+ assertTrue(m >= 0);
+ assertTrue(m < b);
+ }
+ }
+ }
+ }
+
+ private long poorManFloorDiv(long a, long b) {
+
+ // find q0, r0 such that a = q0 b + r0
+ BigInteger q0 = BigInteger.valueOf(a / b);
+ BigInteger r0 = BigInteger.valueOf(a % b);
+ BigInteger fd = BigInteger.valueOf(Integer.MIN_VALUE);
+ BigInteger bigB = BigInteger.valueOf(b);
+
+ for (int k = -2; k < 2; ++k) {
+ // find another pair q, r such that a = q b + r
+ BigInteger bigK = BigInteger.valueOf(k);
+ BigInteger q = q0.subtract(bigK);
+ BigInteger r = r0.add(bigK.multiply(bigB));
+ if (r.abs().compareTo(bigB.abs()) < 0 &&
+ (r.longValue() == 0l || ((r.longValue() ^ b) & 0x8000000000000000l) == 0)) {
+ if (fd.compareTo(q) < 0) {
+ fd = q;
+ }
+ }
+ }
+
+ return fd.longValue();
+
+ }
+
+ private long poorManFloorMod(long a, long b) {
+ return a - b * poorManFloorDiv(a, b);
+ }
+
+ /**
+ * http://bugs.java.com/bugdatabase/view_bug.do?bug_id=6430675
+ */
+ @Test
+ public void testRoundDown() {
+ double x = 0x1.fffffffffffffp-2; // greatest floating point value less than 0.5
+ assertTrue(x < 0.5d);
+ assertEquals(0, AccurateMath.round(x));
+
+ x = 4503599627370497.0; // x = Math.pow(2, 52) + 1;
+ assertEquals("4503599627370497", new BigDecimal(x).toString());
+ assertTrue(x == Math.rint(x));
+ assertTrue(x == AccurateMath.round(x));
+ //assertTrue(x == Math.round(x)); // fails with Java 7, fixed in Java 8
+ }
+
+}
diff --git a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/util/FastMathTest.java b/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMathTest.java.bak
similarity index 67%
rename from commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/util/FastMathTest.java
rename to commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMathTest.java.bak
index b37623996..52b58f07e 100644
--- a/commons-math-legacy/src/test/java/org/apache/commons/math4/legacy/util/FastMathTest.java
+++ b/commons-math-legacy-core/src/test/java/org/apache/commons/math4/legacy/core/jdkmath/AccurateMathTest.java.bak
@@ -41,7 +41,7 @@ import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
-public class FastMathTest {
+public class AccurateMathTest {
private static final double MAX_ERROR_ULP = 0.51;
private static final int NUMBER_OF_TRIALS = 1000;
@@ -72,19 +72,19 @@ public class FastMathTest {
for (double[] pair : pairs) {
assertEquals("min(" + pair[0] + ", " + pair[1] + ")",
Math.min(pair[0], pair[1]),
- FastMath.min(pair[0], pair[1]),
+ AccurateMath.min(pair[0], pair[1]),
Precision.EPSILON);
assertEquals("min(" + pair[1] + ", " + pair[0] + ")",
Math.min(pair[1], pair[0]),
- FastMath.min(pair[1], pair[0]),
+ AccurateMath.min(pair[1], pair[0]),
Precision.EPSILON);
assertEquals("max(" + pair[0] + ", " + pair[1] + ")",
Math.max(pair[0], pair[1]),
- FastMath.max(pair[0], pair[1]),
+ AccurateMath.max(pair[0], pair[1]),
Precision.EPSILON);
assertEquals("max(" + pair[1] + ", " + pair[0] + ")",
Math.max(pair[1], pair[0]),
- FastMath.max(pair[1], pair[0]),
+ AccurateMath.max(pair[1], pair[0]),
Precision.EPSILON);
}
}
@@ -105,62 +105,62 @@ public class FastMathTest {
for (float[] pair : pairs) {
assertEquals("min(" + pair[0] + ", " + pair[1] + ")",
Math.min(pair[0], pair[1]),
- FastMath.min(pair[0], pair[1]),
+ AccurateMath.min(pair[0], pair[1]),
Precision.EPSILON);
assertEquals("min(" + pair[1] + ", " + pair[0] + ")",
Math.min(pair[1], pair[0]),
- FastMath.min(pair[1], pair[0]),
+ AccurateMath.min(pair[1], pair[0]),
Precision.EPSILON);
assertEquals("max(" + pair[0] + ", " + pair[1] + ")",
Math.max(pair[0], pair[1]),
- FastMath.max(pair[0], pair[1]),
+ AccurateMath.max(pair[0], pair[1]),
Precision.EPSILON);
assertEquals("max(" + pair[1] + ", " + pair[0] + ")",
Math.max(pair[1], pair[0]),
- FastMath.max(pair[1], pair[0]),
+ AccurateMath.max(pair[1], pair[0]),
Precision.EPSILON);
}
}
@Test
public void testConstants() {
- assertEquals(Math.PI, FastMath.PI, 1.0e-20);
- assertEquals(Math.E, FastMath.E, 1.0e-20);
+ assertEquals(Math.PI, AccurateMath.PI, 1.0e-20);
+ assertEquals(Math.E, AccurateMath.E, 1.0e-20);
}
@Test
public void testAtan2() {
double y1 = 1.2713504628280707e10;
double x1 = -5.674940885228782e-10;
- assertEquals(Math.atan2(y1, x1), FastMath.atan2(y1, x1), 2 * Precision.EPSILON);
+ assertEquals(Math.atan2(y1, x1), AccurateMath.atan2(y1, x1), 2 * Precision.EPSILON);
double y2 = 0.0;
double x2 = Double.POSITIVE_INFINITY;
- assertEquals(Math.atan2(y2, x2), FastMath.atan2(y2, x2), Precision.SAFE_MIN);
+ assertEquals(Math.atan2(y2, x2), AccurateMath.atan2(y2, x2), Precision.SAFE_MIN);
}
@Test
public void testHyperbolic() {
double maxErr = 0;
for (double x = -30; x < 30; x += 0.001) {
- double tst = FastMath.sinh(x);
+ double tst = AccurateMath.sinh(x);
double ref = Math.sinh(x);
- maxErr = FastMath.max(maxErr, FastMath.abs(ref - tst) / FastMath.ulp(ref));
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(ref - tst) / AccurateMath.ulp(ref));
}
assertEquals(0, maxErr, 2);
maxErr = 0;
for (double x = -30; x < 30; x += 0.001) {
- double tst = FastMath.cosh(x);
+ double tst = AccurateMath.cosh(x);
double ref = Math.cosh(x);
- maxErr = FastMath.max(maxErr, FastMath.abs(ref - tst) / FastMath.ulp(ref));
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(ref - tst) / AccurateMath.ulp(ref));
}
assertEquals(0, maxErr, 2);
maxErr = 0;
for (double x = -0.5; x < 0.5; x += 0.001) {
- double tst = FastMath.tanh(x);
+ double tst = AccurateMath.tanh(x);
double ref = Math.tanh(x);
- maxErr = FastMath.max(maxErr, FastMath.abs(ref - tst) / FastMath.ulp(ref));
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(ref - tst) / AccurateMath.ulp(ref));
}
assertEquals(0, maxErr, 4);
@@ -171,9 +171,9 @@ public class FastMathTest {
final double x = -1;
final double y = (5 + 1e-15) * 1e15;
assertEquals(Math.pow(x, y),
- FastMath.pow(x, y), 0);
+ AccurateMath.pow(x, y), 0);
assertEquals(Math.pow(x, -y),
- FastMath.pow(x, -y), 0);
+ AccurateMath.pow(x, -y), 0);
}
@Test
@@ -184,16 +184,16 @@ public class FastMathTest {
double maxErr = 0;
for (double x = start; x < end; x += 1e-3) {
- final double tst = FastMath.cosh(x);
+ final double tst = AccurateMath.cosh(x);
final double ref = Math.cosh(x);
- maxErr = FastMath.max(maxErr, FastMath.abs(ref - tst) / FastMath.ulp(ref));
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(ref - tst) / AccurateMath.ulp(ref));
}
assertEquals(0, maxErr, 3);
for (double x = start; x < end; x += 1e-3) {
- final double tst = FastMath.sinh(x);
+ final double tst = AccurateMath.sinh(x);
final double ref = Math.sinh(x);
- maxErr = FastMath.max(maxErr, FastMath.abs(ref - tst) / FastMath.ulp(ref));
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(ref - tst) / AccurateMath.ulp(ref));
}
assertEquals(0, maxErr, 3);
}
@@ -206,16 +206,16 @@ public class FastMathTest {
double maxErr = 0;
for (double x = start; x > end; x -= 1e-3) {
- final double tst = FastMath.cosh(x);
+ final double tst = AccurateMath.cosh(x);
final double ref = Math.cosh(x);
- maxErr = FastMath.max(maxErr, FastMath.abs(ref - tst) / FastMath.ulp(ref));
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(ref - tst) / AccurateMath.ulp(ref));
}
assertEquals(0, maxErr, 3);
for (double x = start; x > end; x -= 1e-3) {
- final double tst = FastMath.sinh(x);
+ final double tst = AccurateMath.sinh(x);
final double ref = Math.sinh(x);
- maxErr = FastMath.max(maxErr, FastMath.abs(ref - tst) / FastMath.ulp(ref));
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(ref - tst) / AccurateMath.ulp(ref));
}
assertEquals(0, maxErr, 3);
}
@@ -224,7 +224,7 @@ public class FastMathTest {
public void testMath1269() {
final double arg = 709.8125;
final double vM = Math.exp(arg);
- final double vFM = FastMath.exp(arg);
+ final double vFM = AccurateMath.exp(arg);
assertTrue("exp(" + arg + ") is " + vFM + " instead of " + vM,
Precision.equalsIncludingNaN(vM, vFM));
}
@@ -233,19 +233,19 @@ public class FastMathTest {
public void testHyperbolicInverses() {
double maxErr = 0;
for (double x = -30; x < 30; x += 0.01) {
- maxErr = FastMath.max(maxErr, FastMath.abs(x - FastMath.sinh(FastMath.asinh(x))) / (2 * FastMath.ulp(x)));
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(x - AccurateMath.sinh(AccurateMath.asinh(x))) / (2 * AccurateMath.ulp(x)));
}
assertEquals(0, maxErr, 3);
maxErr = 0;
for (double x = 1; x < 30; x += 0.01) {
- maxErr = FastMath.max(maxErr, FastMath.abs(x - FastMath.cosh(FastMath.acosh(x))) / (2 * FastMath.ulp(x)));
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(x - AccurateMath.cosh(AccurateMath.acosh(x))) / (2 * AccurateMath.ulp(x)));
}
assertEquals(0, maxErr, 2);
maxErr = 0;
for (double x = -1 + Precision.EPSILON; x < 1 - Precision.EPSILON; x += 0.0001) {
- maxErr = FastMath.max(maxErr, FastMath.abs(x - FastMath.tanh(FastMath.atanh(x))) / (2 * FastMath.ulp(x)));
+ maxErr = AccurateMath.max(maxErr, AccurateMath.abs(x - AccurateMath.tanh(AccurateMath.atanh(x))) / (2 * AccurateMath.ulp(x)));
}
assertEquals(0, maxErr, 2);
}
@@ -257,7 +257,7 @@ public class FastMathTest {
for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
double x = Math.exp(generator.nextDouble() * 1416.0 - 708.0) * generator.nextDouble();
// double x = generator.nextDouble()*2.0;
- double tst = FastMath.log(x);
+ double tst = AccurateMath.log(x);
double ref = DfpMath.log(field.newDfp(x)).toDouble();
double err = (tst - ref) / ref;
@@ -281,7 +281,7 @@ public class FastMathTest {
for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
double x = Math.exp(generator.nextDouble() * 1416.0 - 708.0) * generator.nextDouble();
// double x = generator.nextDouble()*2.0;
- double tst = FastMath.log10(x);
+ double tst = AccurateMath.log10(x);
double ref = DfpMath.log(field.newDfp(x)).divide(DfpMath.log(field.newDfp("10"))).toDouble();
double err = (tst - ref) / ref;
@@ -305,7 +305,7 @@ public class FastMathTest {
for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
double x = Math.exp(generator.nextDouble() * 10.0 - 5.0) * generator.nextDouble();
// double x = generator.nextDouble()*2.0;
- double tst = FastMath.log1p(x);
+ double tst = AccurateMath.log1p(x);
double ref = DfpMath.log(field.newDfp(x).add(field.getOne())).toDouble();
double err = (tst - ref) / ref;
@@ -324,93 +324,93 @@ public class FastMathTest {
@Test
public void testLog1pSpecialCases() {
- assertTrue("Logp of -1.0 should be -Inf", Double.isInfinite(FastMath.log1p(-1.0)));
+ assertTrue("Logp of -1.0 should be -Inf", Double.isInfinite(AccurateMath.log1p(-1.0)));
}
@Test
public void testLogSpecialCases() {
- assertEquals("Log of zero should be -Inf", Double.NEGATIVE_INFINITY, FastMath.log(0.0), 1.0);
- assertEquals("Log of -zero should be -Inf", Double.NEGATIVE_INFINITY, FastMath.log(-0.0), 1.0);
- assertTrue("Log of NaN should be NaN", Double.isNaN(FastMath.log(Double.NaN)));
- assertTrue("Log of negative number should be NaN", Double.isNaN(FastMath.log(-1.0)));
- assertEquals("Log of Double.MIN_VALUE should be -744.4400719213812", -744.4400719213812, FastMath.log(Double.MIN_VALUE), Precision.EPSILON);
- assertEquals("Log of infinity should be infinity", Double.POSITIVE_INFINITY, FastMath.log(Double.POSITIVE_INFINITY), 1.0);
+ assertEquals("Log of zero should be -Inf", Double.NEGATIVE_INFINITY, AccurateMath.log(0.0), 1.0);
+ assertEquals("Log of -zero should be -Inf", Double.NEGATIVE_INFINITY, AccurateMath.log(-0.0), 1.0);
+ assertTrue("Log of NaN should be NaN", Double.isNaN(AccurateMath.log(Double.NaN)));
+ assertTrue("Log of negative number should be NaN", Double.isNaN(AccurateMath.log(-1.0)));
+ assertEquals("Log of Double.MIN_VALUE should be -744.4400719213812", -744.4400719213812, AccurateMath.log(Double.MIN_VALUE), Precision.EPSILON);
+ assertEquals("Log of infinity should be infinity", Double.POSITIVE_INFINITY, AccurateMath.log(Double.POSITIVE_INFINITY), 1.0);
}
@Test
public void testExpSpecialCases() {
// Smallest value that will round up to Double.MIN_VALUE
- assertEquals(Double.MIN_VALUE, FastMath.exp(-745.1332191019411), Precision.EPSILON);
- assertEquals("exp(-745.1332191019412) should be 0.0", 0.0, FastMath.exp(-745.1332191019412), Precision.EPSILON);
- assertTrue("exp of NaN should be NaN", Double.isNaN(FastMath.exp(Double.NaN)));
- assertEquals("exp of infinity should be infinity", Double.POSITIVE_INFINITY, FastMath.exp(Double.POSITIVE_INFINITY), 1.0);
- assertEquals("exp of -infinity should be 0.0", 0.0, FastMath.exp(Double.NEGATIVE_INFINITY), Precision.EPSILON);
- assertEquals("exp(1) should be Math.E", Math.E, FastMath.exp(1.0), Precision.EPSILON);
+ assertEquals(Double.MIN_VALUE, AccurateMath.exp(-745.1332191019411), Precision.EPSILON);
+ assertEquals("exp(-745.1332191019412) should be 0.0", 0.0, AccurateMath.exp(-745.1332191019412), Precision.EPSILON);
+ assertTrue("exp of NaN should be NaN", Double.isNaN(AccurateMath.exp(Double.NaN)));
+ assertEquals("exp of infinity should be infinity", Double.POSITIVE_INFINITY, AccurateMath.exp(Double.POSITIVE_INFINITY), 1.0);
+ assertEquals("exp of -infinity should be 0.0", 0.0, AccurateMath.exp(Double.NEGATIVE_INFINITY), Precision.EPSILON);
+ assertEquals("exp(1) should be Math.E", Math.E, AccurateMath.exp(1.0), Precision.EPSILON);
}
@Test
public void testPowSpecialCases() {
final double EXACT = -1.0;
- assertEquals("pow(-1, 0) should be 1.0", 1.0, FastMath.pow(-1.0, 0.0), Precision.EPSILON);
- assertEquals("pow(-1, -0) should be 1.0", 1.0, FastMath.pow(-1.0, -0.0), Precision.EPSILON);
- assertEquals("pow(PI, 1.0) should be PI", FastMath.PI, FastMath.pow(FastMath.PI, 1.0), Precision.EPSILON);
- assertEquals("pow(-PI, 1.0) should be -PI", -FastMath.PI, FastMath.pow(-FastMath.PI, 1.0), Precision.EPSILON);
- assertTrue("pow(PI, NaN) should be NaN", Double.isNaN(FastMath.pow(Math.PI, Double.NaN)));
- assertTrue("pow(NaN, PI) should be NaN", Double.isNaN(FastMath.pow(Double.NaN, Math.PI)));
- assertEquals("pow(2.0, Infinity) should be Infinity", Double.POSITIVE_INFINITY, FastMath.pow(2.0, Double.POSITIVE_INFINITY), 1.0);
- assertEquals("pow(0.5, -Infinity) should be Infinity", Double.POSITIVE_INFINITY, FastMath.pow(0.5, Double.NEGATIVE_INFINITY), 1.0);
- assertEquals("pow(0.5, Infinity) should be 0.0", 0.0, FastMath.pow(0.5, Double.POSITIVE_INFINITY), Precision.EPSILON);
- assertEquals("pow(2.0, -Infinity) should be 0.0", 0.0, FastMath.pow(2.0, Double.NEGATIVE_INFINITY), Precision.EPSILON);
- assertEquals("pow(0.0, 0.5) should be 0.0", 0.0, FastMath.pow(0.0, 0.5), Precision.EPSILON);
- assertEquals("pow(Infinity, -0.5) should be 0.0", 0.0, FastMath.pow(Double.POSITIVE_INFINITY, -0.5), Precision.EPSILON);
- assertEquals("pow(0.0, -0.5) should be Inf", Double.POSITIVE_INFINITY, FastMath.pow(0.0, -0.5), 1.0);
- assertEquals("pow(Inf, 0.5) should be Inf", Double.POSITIVE_INFINITY, FastMath.pow(Double.POSITIVE_INFINITY, 0.5), 1.0);
- assertEquals("pow(-0.0, -3.0) should be -Inf", Double.NEGATIVE_INFINITY, FastMath.pow(-0.0, -3.0), 1.0);
- assertEquals("pow(-0.0, Infinity) should be 0.0", 0.0, FastMath.pow(-0.0, Double.POSITIVE_INFINITY), Precision.EPSILON);
- assertTrue("pow(-0.0, NaN) should be NaN", Double.isNaN(FastMath.pow(-0.0, Double.NaN)));
- assertEquals("pow(-0.0, -tiny) should be Infinity", Double.POSITIVE_INFINITY, FastMath.pow(-0.0, -Double.MIN_VALUE), 1.0);
- assertEquals("pow(-0.0, -huge) should be Infinity", Double.POSITIVE_INFINITY, FastMath.pow(-0.0, -Double.MAX_VALUE), 1.0);
- assertEquals("pow(-Inf, 3.0) should be -Inf", Double.NEGATIVE_INFINITY, FastMath.pow(Double.NEGATIVE_INFINITY, 3.0), 1.0);
- assertEquals("pow(-Inf, -3.0) should be -0.0", -0.0, FastMath.pow(Double.NEGATIVE_INFINITY, -3.0), EXACT);
- assertEquals("pow(-0.0, -3.5) should be Inf", Double.POSITIVE_INFINITY, FastMath.pow(-0.0, -3.5), 1.0);
- assertEquals("pow(Inf, 3.5) should be Inf", Double.POSITIVE_INFINITY, FastMath.pow(Double.POSITIVE_INFINITY, 3.5), 1.0);
- assertEquals("pow(-2.0, 3.0) should be -8.0", -8.0, FastMath.pow(-2.0, 3.0), Precision.EPSILON);
- assertTrue("pow(-2.0, 3.5) should be NaN", Double.isNaN(FastMath.pow(-2.0, 3.5)));
- assertTrue("pow(NaN, -Infinity) should be NaN", Double.isNaN(FastMath.pow(Double.NaN, Double.NEGATIVE_INFINITY)));
- assertEquals("pow(NaN, 0.0) should be 1.0", 1.0, FastMath.pow(Double.NaN, 0.0), Precision.EPSILON);
- assertEquals("pow(-Infinity, -Infinity) should be 0.0", 0.0, FastMath.pow(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
- assertEquals("pow(-huge, -huge) should be 0.0", 0.0, FastMath.pow(-Double.MAX_VALUE, -Double.MAX_VALUE), Precision.EPSILON);
- assertTrue("pow(-huge, huge) should be +Inf", Double.isInfinite(FastMath.pow(-Double.MAX_VALUE, Double.MAX_VALUE)));
- assertTrue("pow(NaN, -Infinity) should be NaN", Double.isNaN(FastMath.pow(Double.NaN, Double.NEGATIVE_INFINITY)));
- assertEquals("pow(NaN, -0.0) should be 1.0", 1.0, FastMath.pow(Double.NaN, -0.0), Precision.EPSILON);
- assertEquals("pow(-Infinity, -Infinity) should be 0.0", 0.0, FastMath.pow(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
- assertEquals("pow(-huge, -huge) should be 0.0", 0.0, FastMath.pow(-Double.MAX_VALUE, -Double.MAX_VALUE), Precision.EPSILON);
- assertEquals("pow(-huge, huge) should be +Inf", Double.POSITIVE_INFINITY, FastMath.pow(-Double.MAX_VALUE, Double.MAX_VALUE), 1.0);
+ assertEquals("pow(-1, 0) should be 1.0", 1.0, AccurateMath.pow(-1.0, 0.0), Precision.EPSILON);
+ assertEquals("pow(-1, -0) should be 1.0", 1.0, AccurateMath.pow(-1.0, -0.0), Precision.EPSILON);
+ assertEquals("pow(PI, 1.0) should be PI", AccurateMath.PI, AccurateMath.pow(AccurateMath.PI, 1.0), Precision.EPSILON);
+ assertEquals("pow(-PI, 1.0) should be -PI", -AccurateMath.PI, AccurateMath.pow(-AccurateMath.PI, 1.0), Precision.EPSILON);
+ assertTrue("pow(PI, NaN) should be NaN", Double.isNaN(AccurateMath.pow(Math.PI, Double.NaN)));
+ assertTrue("pow(NaN, PI) should be NaN", Double.isNaN(AccurateMath.pow(Double.NaN, Math.PI)));
+ assertEquals("pow(2.0, Infinity) should be Infinity", Double.POSITIVE_INFINITY, AccurateMath.pow(2.0, Double.POSITIVE_INFINITY), 1.0);
+ assertEquals("pow(0.5, -Infinity) should be Infinity", Double.POSITIVE_INFINITY, AccurateMath.pow(0.5, Double.NEGATIVE_INFINITY), 1.0);
+ assertEquals("pow(0.5, Infinity) should be 0.0", 0.0, AccurateMath.pow(0.5, Double.POSITIVE_INFINITY), Precision.EPSILON);
+ assertEquals("pow(2.0, -Infinity) should be 0.0", 0.0, AccurateMath.pow(2.0, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+ assertEquals("pow(0.0, 0.5) should be 0.0", 0.0, AccurateMath.pow(0.0, 0.5), Precision.EPSILON);
+ assertEquals("pow(Infinity, -0.5) should be 0.0", 0.0, AccurateMath.pow(Double.POSITIVE_INFINITY, -0.5), Precision.EPSILON);
+ assertEquals("pow(0.0, -0.5) should be Inf", Double.POSITIVE_INFINITY, AccurateMath.pow(0.0, -0.5), 1.0);
+ assertEquals("pow(Inf, 0.5) should be Inf", Double.POSITIVE_INFINITY, AccurateMath.pow(Double.POSITIVE_INFINITY, 0.5), 1.0);
+ assertEquals("pow(-0.0, -3.0) should be -Inf", Double.NEGATIVE_INFINITY, AccurateMath.pow(-0.0, -3.0), 1.0);
+ assertEquals("pow(-0.0, Infinity) should be 0.0", 0.0, AccurateMath.pow(-0.0, Double.POSITIVE_INFINITY), Precision.EPSILON);
+ assertTrue("pow(-0.0, NaN) should be NaN", Double.isNaN(AccurateMath.pow(-0.0, Double.NaN)));
+ assertEquals("pow(-0.0, -tiny) should be Infinity", Double.POSITIVE_INFINITY, AccurateMath.pow(-0.0, -Double.MIN_VALUE), 1.0);
+ assertEquals("pow(-0.0, -huge) should be Infinity", Double.POSITIVE_INFINITY, AccurateMath.pow(-0.0, -Double.MAX_VALUE), 1.0);
+ assertEquals("pow(-Inf, 3.0) should be -Inf", Double.NEGATIVE_INFINITY, AccurateMath.pow(Double.NEGATIVE_INFINITY, 3.0), 1.0);
+ assertEquals("pow(-Inf, -3.0) should be -0.0", -0.0, AccurateMath.pow(Double.NEGATIVE_INFINITY, -3.0), EXACT);
+ assertEquals("pow(-0.0, -3.5) should be Inf", Double.POSITIVE_INFINITY, AccurateMath.pow(-0.0, -3.5), 1.0);
+ assertEquals("pow(Inf, 3.5) should be Inf", Double.POSITIVE_INFINITY, AccurateMath.pow(Double.POSITIVE_INFINITY, 3.5), 1.0);
+ assertEquals("pow(-2.0, 3.0) should be -8.0", -8.0, AccurateMath.pow(-2.0, 3.0), Precision.EPSILON);
+ assertTrue("pow(-2.0, 3.5) should be NaN", Double.isNaN(AccurateMath.pow(-2.0, 3.5)));
+ assertTrue("pow(NaN, -Infinity) should be NaN", Double.isNaN(AccurateMath.pow(Double.NaN, Double.NEGATIVE_INFINITY)));
+ assertEquals("pow(NaN, 0.0) should be 1.0", 1.0, AccurateMath.pow(Double.NaN, 0.0), Precision.EPSILON);
+ assertEquals("pow(-Infinity, -Infinity) should be 0.0", 0.0, AccurateMath.pow(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+ assertEquals("pow(-huge, -huge) should be 0.0", 0.0, AccurateMath.pow(-Double.MAX_VALUE, -Double.MAX_VALUE), Precision.EPSILON);
+ assertTrue("pow(-huge, huge) should be +Inf", Double.isInfinite(AccurateMath.pow(-Double.MAX_VALUE, Double.MAX_VALUE)));
+ assertTrue("pow(NaN, -Infinity) should be NaN", Double.isNaN(AccurateMath.pow(Double.NaN, Double.NEGATIVE_INFINITY)));
+ assertEquals("pow(NaN, -0.0) should be 1.0", 1.0, AccurateMath.pow(Double.NaN, -0.0), Precision.EPSILON);
+ assertEquals("pow(-Infinity, -Infinity) should be 0.0", 0.0, AccurateMath.pow(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+ assertEquals("pow(-huge, -huge) should be 0.0", 0.0, AccurateMath.pow(-Double.MAX_VALUE, -Double.MAX_VALUE), Precision.EPSILON);
+ assertEquals("pow(-huge, huge) should be +Inf", Double.POSITIVE_INFINITY, AccurateMath.pow(-Double.MAX_VALUE, Double.MAX_VALUE), 1.0);
// Added tests for a 100% coverage
- assertTrue("pow(+Inf, NaN) should be NaN", Double.isNaN(FastMath.pow(Double.POSITIVE_INFINITY, Double.NaN)));
- assertTrue("pow(1.0, +Inf) should be NaN", Double.isNaN(FastMath.pow(1.0, Double.POSITIVE_INFINITY)));
- assertTrue("pow(-Inf, NaN) should be NaN", Double.isNaN(FastMath.pow(Double.NEGATIVE_INFINITY, Double.NaN)));
- assertEquals("pow(-Inf, -1.0) should be -0.0", -0.0, FastMath.pow(Double.NEGATIVE_INFINITY, -1.0), EXACT);
- assertEquals("pow(-Inf, -2.0) should be 0.0", 0.0, FastMath.pow(Double.NEGATIVE_INFINITY, -2.0), EXACT);
- assertEquals("pow(-Inf, 1.0) should be -Inf", Double.NEGATIVE_INFINITY, FastMath.pow(Double.NEGATIVE_INFINITY, 1.0), 1.0);
- assertEquals("pow(-Inf, 2.0) should be +Inf", Double.POSITIVE_INFINITY, FastMath.pow(Double.NEGATIVE_INFINITY, 2.0), 1.0);
- assertTrue("pow(1.0, -Inf) should be NaN", Double.isNaN(FastMath.pow(1.0, Double.NEGATIVE_INFINITY)));
- assertEquals("pow(-0.0, 1.0) should be -0.0", -0.0, FastMath.pow(-0.0, 1.0), EXACT);
- assertEquals("pow(0.0, 1.0) should be 0.0", 0.0, FastMath.pow(0.0, 1.0), EXACT);
- assertEquals("pow(0.0, +Inf) should be 0.0", 0.0, FastMath.pow(0.0, Double.POSITIVE_INFINITY), EXACT);
- assertEquals("pow(-0.0, even) should be 0.0", 0.0, FastMath.pow(-0.0, 6.0), EXACT);
- assertEquals("pow(-0.0, odd) should be -0.0", -0.0, FastMath.pow(-0.0, 13.0), EXACT);
- assertEquals("pow(-0.0, -even) should be +Inf", Double.POSITIVE_INFINITY, FastMath.pow(-0.0, -6.0), EXACT);
- assertEquals("pow(-0.0, -odd) should be -Inf", Double.NEGATIVE_INFINITY, FastMath.pow(-0.0, -13.0), EXACT);
- assertEquals("pow(-2.0, 4.0) should be 16.0", 16.0, FastMath.pow(-2.0, 4.0), EXACT);
- assertEquals("pow(-2.0, 4.5) should be NaN", Double.NaN, FastMath.pow(-2.0, 4.5), EXACT);
- assertEquals("pow(-0.0, -0.0) should be 1.0", 1.0, FastMath.pow(-0.0, -0.0), EXACT);
- assertEquals("pow(-0.0, 0.0) should be 1.0", 1.0, FastMath.pow(-0.0, 0.0), EXACT);
- assertEquals("pow(0.0, -0.0) should be 1.0", 1.0, FastMath.pow(0.0, -0.0), EXACT);
- assertEquals("pow(0.0, 0.0) should be 1.0", 1.0, FastMath.pow(0.0, 0.0), EXACT);
+ assertTrue("pow(+Inf, NaN) should be NaN", Double.isNaN(AccurateMath.pow(Double.POSITIVE_INFINITY, Double.NaN)));
+ assertTrue("pow(1.0, +Inf) should be NaN", Double.isNaN(AccurateMath.pow(1.0, Double.POSITIVE_INFINITY)));
+ assertTrue("pow(-Inf, NaN) should be NaN", Double.isNaN(AccurateMath.pow(Double.NEGATIVE_INFINITY, Double.NaN)));
+ assertEquals("pow(-Inf, -1.0) should be -0.0", -0.0, AccurateMath.pow(Double.NEGATIVE_INFINITY, -1.0), EXACT);
+ assertEquals("pow(-Inf, -2.0) should be 0.0", 0.0, AccurateMath.pow(Double.NEGATIVE_INFINITY, -2.0), EXACT);
+ assertEquals("pow(-Inf, 1.0) should be -Inf", Double.NEGATIVE_INFINITY, AccurateMath.pow(Double.NEGATIVE_INFINITY, 1.0), 1.0);
+ assertEquals("pow(-Inf, 2.0) should be +Inf", Double.POSITIVE_INFINITY, AccurateMath.pow(Double.NEGATIVE_INFINITY, 2.0), 1.0);
+ assertTrue("pow(1.0, -Inf) should be NaN", Double.isNaN(AccurateMath.pow(1.0, Double.NEGATIVE_INFINITY)));
+ assertEquals("pow(-0.0, 1.0) should be -0.0", -0.0, AccurateMath.pow(-0.0, 1.0), EXACT);
+ assertEquals("pow(0.0, 1.0) should be 0.0", 0.0, AccurateMath.pow(0.0, 1.0), EXACT);
+ assertEquals("pow(0.0, +Inf) should be 0.0", 0.0, AccurateMath.pow(0.0, Double.POSITIVE_INFINITY), EXACT);
+ assertEquals("pow(-0.0, even) should be 0.0", 0.0, AccurateMath.pow(-0.0, 6.0), EXACT);
+ assertEquals("pow(-0.0, odd) should be -0.0", -0.0, AccurateMath.pow(-0.0, 13.0), EXACT);
+ assertEquals("pow(-0.0, -even) should be +Inf", Double.POSITIVE_INFINITY, AccurateMath.pow(-0.0, -6.0), EXACT);
+ assertEquals("pow(-0.0, -odd) should be -Inf", Double.NEGATIVE_INFINITY, AccurateMath.pow(-0.0, -13.0), EXACT);
+ assertEquals("pow(-2.0, 4.0) should be 16.0", 16.0, AccurateMath.pow(-2.0, 4.0), EXACT);
+ assertEquals("pow(-2.0, 4.5) should be NaN", Double.NaN, AccurateMath.pow(-2.0, 4.5), EXACT);
+ assertEquals("pow(-0.0, -0.0) should be 1.0", 1.0, AccurateMath.pow(-0.0, -0.0), EXACT);
+ assertEquals("pow(-0.0, 0.0) should be 1.0", 1.0, AccurateMath.pow(-0.0, 0.0), EXACT);
+ assertEquals("pow(0.0, -0.0) should be 1.0", 1.0, AccurateMath.pow(0.0, -0.0), EXACT);
+ assertEquals("pow(0.0, 0.0) should be 1.0", 1.0, AccurateMath.pow(0.0, 0.0), EXACT);
}
@Test(timeout=20000L)
@@ -432,124 +432,124 @@ public class FastMathTest {
// Special cases from Math.pow javadoc:
// If the second argument is positive or negative zero, then the result is 1.0.
for (double d : DOUBLES) {
- assertEquals(1.0, FastMath.pow(d, 0.0), EXACT);
+ assertEquals(1.0, AccurateMath.pow(d, 0.0), EXACT);
}
for (double d : DOUBLES) {
- assertEquals(1.0, FastMath.pow(d, -0.0), EXACT);
+ assertEquals(1.0, AccurateMath.pow(d, -0.0), EXACT);
}
// If the second argument is 1.0, then the result is the same as the first argument.
for (double d : DOUBLES) {
- assertEquals(d, FastMath.pow(d, 1.0), EXACT);
+ assertEquals(d, AccurateMath.pow(d, 1.0), EXACT);
}
// If the second argument is NaN, then the result is NaN.
for (double d : DOUBLES) {
- assertEquals(Double.NaN, FastMath.pow(d, Double.NaN), EXACT);
+ assertEquals(Double.NaN, AccurateMath.pow(d, Double.NaN), EXACT);
}
// If the first argument is NaN and the second argument is nonzero, then the result is NaN.
for (double i : DOUBLES) {
if (i != 0.0) {
- assertEquals(Double.NaN, FastMath.pow(Double.NaN, i), EXACT);
+ assertEquals(Double.NaN, AccurateMath.pow(Double.NaN, i), EXACT);
}
}
// If the absolute value of the first argument is greater than 1 and the second argument is positive infinity, or
// the absolute value of the first argument is less than 1 and the second argument is negative infinity, then the result is positive infinity.
for (double d : DOUBLES) {
if (Math.abs(d) > 1.0) {
- assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(d, Double.POSITIVE_INFINITY), EXACT);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(d, Double.POSITIVE_INFINITY), EXACT);
}
}
for (double d : DOUBLES) {
if (Math.abs(d) < 1.0) {
- assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(d, Double.NEGATIVE_INFINITY), EXACT);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(d, Double.NEGATIVE_INFINITY), EXACT);
}
}
// If the absolute value of the first argument is greater than 1 and the second argument is negative infinity, or
// the absolute value of the first argument is less than 1 and the second argument is positive infinity, then the result is positive zero.
for (double d : DOUBLES) {
if (Math.abs(d) > 1.0) {
- assertEquals(0.0, FastMath.pow(d, Double.NEGATIVE_INFINITY), EXACT);
+ assertEquals(0.0, AccurateMath.pow(d, Double.NEGATIVE_INFINITY), EXACT);
}
}
for (double d : DOUBLES) {
if (Math.abs(d) < 1.0) {
- assertEquals(0.0, FastMath.pow(d, Double.POSITIVE_INFINITY), EXACT);
+ assertEquals(0.0, AccurateMath.pow(d, Double.POSITIVE_INFINITY), EXACT);
}
}
// If the absolute value of the first argument equals 1 and the second argument is infinite, then the result is NaN.
- assertEquals(Double.NaN, FastMath.pow(1.0, Double.POSITIVE_INFINITY), EXACT);
- assertEquals(Double.NaN, FastMath.pow(1.0, Double.NEGATIVE_INFINITY), EXACT);
- assertEquals(Double.NaN, FastMath.pow(-1.0, Double.POSITIVE_INFINITY), EXACT);
- assertEquals(Double.NaN, FastMath.pow(-1.0, Double.NEGATIVE_INFINITY), EXACT);
+ assertEquals(Double.NaN, AccurateMath.pow(1.0, Double.POSITIVE_INFINITY), EXACT);
+ assertEquals(Double.NaN, AccurateMath.pow(1.0, Double.NEGATIVE_INFINITY), EXACT);
+ assertEquals(Double.NaN, AccurateMath.pow(-1.0, Double.POSITIVE_INFINITY), EXACT);
+ assertEquals(Double.NaN, AccurateMath.pow(-1.0, Double.NEGATIVE_INFINITY), EXACT);
// If the first argument is positive zero and the second argument is greater than zero, or
// the first argument is positive infinity and the second argument is less than zero, then the result is positive zero.
for (double i : DOUBLES) {
if (i > 0.0) {
- assertEquals(0.0, FastMath.pow(0.0, i), EXACT);
+ assertEquals(0.0, AccurateMath.pow(0.0, i), EXACT);
}
}
for (double i : DOUBLES) {
if (i < 0.0) {
- assertEquals(0.0, FastMath.pow(Double.POSITIVE_INFINITY, i), EXACT);
+ assertEquals(0.0, AccurateMath.pow(Double.POSITIVE_INFINITY, i), EXACT);
}
}
// If the first argument is positive zero and the second argument is less than zero, or
// the first argument is positive infinity and the second argument is greater than zero, then the result is positive infinity.
for (double i : DOUBLES) {
if (i < 0.0) {
- assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(0.0, i), EXACT);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(0.0, i), EXACT);
}
}
for (double i : DOUBLES) {
if (i > 0.0) {
- assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(Double.POSITIVE_INFINITY, i), EXACT);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(Double.POSITIVE_INFINITY, i), EXACT);
}
}
// If the first argument is negative zero and the second argument is greater than zero but not a finite odd integer, or
// the first argument is negative infinity and the second argument is less than zero but not a finite odd integer, then the result is positive zero.
for (double i : DOUBLES) {
if (i > 0.0 && (Double.isInfinite(i) || i % 2.0 == 0.0)) {
- assertEquals(0.0, FastMath.pow(-0.0, i), EXACT);
+ assertEquals(0.0, AccurateMath.pow(-0.0, i), EXACT);
}
}
for (double i : DOUBLES) {
if (i < 0.0 && (Double.isInfinite(i) || i % 2.0 == 0.0)) {
- assertEquals(0.0, FastMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+ assertEquals(0.0, AccurateMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
}
}
// If the first argument is negative zero and the second argument is a positive finite odd integer, or
// the first argument is negative infinity and the second argument is a negative finite odd integer, then the result is negative zero.
for (double i : DOUBLES) {
if (i > 0.0 && i % 2.0 == 1.0) {
- assertEquals(-0.0, FastMath.pow(-0.0, i), EXACT);
+ assertEquals(-0.0, AccurateMath.pow(-0.0, i), EXACT);
}
}
for (double i : DOUBLES) {
if (i < 0.0 && i % 2.0 == -1.0) {
- assertEquals(-0.0, FastMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+ assertEquals(-0.0, AccurateMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
}
}
// If the first argument is negative zero and the second argument is less than zero but not a finite odd integer, or
// the first argument is negative infinity and the second argument is greater than zero but not a finite odd integer, then the result is positive infinity.
for (double i : DOUBLES) {
if (i > 0.0 && (Double.isInfinite(i) || i % 2.0 == 0.0)) {
- assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
}
}
for (double i : DOUBLES) {
if (i < 0.0 && (Double.isInfinite(i) || i % 2.0 == 0.0)) {
- assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(-0.0, i), EXACT);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(-0.0, i), EXACT);
}
}
// If the first argument is negative zero and the second argument is a negative finite odd integer, or
// the first argument is negative infinity and the second argument is a positive finite odd integer, then the result is negative infinity.
for (double i : DOUBLES) {
if (i > 0.0 && i % 2.0 == 1.0) {
- assertEquals(Double.NEGATIVE_INFINITY, FastMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
}
}
for (double i : DOUBLES) {
if (i < 0.0 && i % 2.0 == -1.0) {
- assertEquals(Double.NEGATIVE_INFINITY, FastMath.pow(-0.0, i), EXACT);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.pow(-0.0, i), EXACT);
}
}
for (double d : DOUBLES) {
@@ -558,11 +558,11 @@ public class FastMathTest {
for (double i : DOUBLES) {
if (Math.abs(i) <= Double.MAX_VALUE) {
// if the second argument is a finite even integer, the result is equal to the result of raising the absolute value of the first argument to the power of the second argument
- if (i % 2.0 == 0.0) assertEquals(FastMath.pow(-d, i), FastMath.pow(d, i), EXACT);
+ if (i % 2.0 == 0.0) assertEquals(AccurateMath.pow(-d, i), AccurateMath.pow(d, i), EXACT);
// if the second argument is a finite odd integer, the result is equal to the negative of the result of raising the absolute value of the first argument to the power of the second argument
- else if (Math.abs(i) % 2.0 == 1.0) assertEquals(-FastMath.pow(-d, i), FastMath.pow(d, i), EXACT);
+ else if (Math.abs(i) % 2.0 == 1.0) assertEquals(-AccurateMath.pow(-d, i), AccurateMath.pow(d, i), EXACT);
// if the second argument is finite and not an integer, then the result is NaN.
- else assertEquals(Double.NaN, FastMath.pow(d, i), EXACT);
+ else assertEquals(Double.NaN, AccurateMath.pow(d, i), EXACT);
}
}
}
@@ -594,7 +594,7 @@ public class FastMathTest {
if (dNegative && bi.testBit( 0 )) {
expected = -expected;
}
- assertEquals(d + "^" + i + "=" + expected + ", Math.pow=" + Math.pow(d, i), expected, FastMath.pow(d, i), expected == 0.0 || Double.isInfinite(expected) || Double.isNaN(expected) ? EXACT : 2.0 * Math.ulp(expected));
+ assertEquals(d + "^" + i + "=" + expected + ", Math.pow=" + Math.pow(d, i), expected, AccurateMath.pow(d, i), expected == 0.0 || Double.isInfinite(expected) || Double.isNaN(expected) ? EXACT : 2.0 * Math.ulp(expected));
}
}
}
@@ -603,46 +603,46 @@ public class FastMathTest {
@Test
public void testPowLargeIntegralDouble() {
- double y = FastMath.scalb(1.0, 65);
- assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(FastMath.nextUp(1.0), y), 1.0);
- assertEquals(1.0, FastMath.pow(1.0, y), 1.0);
- assertEquals(0.0, FastMath.pow(FastMath.nextDown(1.0), y), 1.0);
- assertEquals(0.0, FastMath.pow(FastMath.nextUp(-1.0), y), 1.0);
- assertEquals(1.0, FastMath.pow(-1.0, y), 1.0);
- assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(FastMath.nextDown(-1.0), y), 1.0);
+ double y = AccurateMath.scalb(1.0, 65);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(AccurateMath.nextUp(1.0), y), 1.0);
+ assertEquals(1.0, AccurateMath.pow(1.0, y), 1.0);
+ assertEquals(0.0, AccurateMath.pow(AccurateMath.nextDown(1.0), y), 1.0);
+ assertEquals(0.0, AccurateMath.pow(AccurateMath.nextUp(-1.0), y), 1.0);
+ assertEquals(1.0, AccurateMath.pow(-1.0, y), 1.0);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(AccurateMath.nextDown(-1.0), y), 1.0);
}
@Test
public void testAtan2SpecialCases() {
- assertTrue("atan2(NaN, 0.0) should be NaN", Double.isNaN(FastMath.atan2(Double.NaN, 0.0)));
- assertTrue("atan2(0.0, NaN) should be NaN", Double.isNaN(FastMath.atan2(0.0, Double.NaN)));
- assertEquals("atan2(0.0, 0.0) should be 0.0", 0.0, FastMath.atan2(0.0, 0.0), Precision.EPSILON);
- assertEquals("atan2(0.0, 0.001) should be 0.0", 0.0, FastMath.atan2(0.0, 0.001), Precision.EPSILON);
- assertEquals("atan2(0.1, +Inf) should be 0.0", 0.0, FastMath.atan2(0.1, Double.POSITIVE_INFINITY), Precision.EPSILON);
- assertEquals("atan2(-0.0, 0.0) should be -0.0", -0.0, FastMath.atan2(-0.0, 0.0), Precision.EPSILON);
- assertEquals("atan2(-0.0, 0.001) should be -0.0", -0.0, FastMath.atan2(-0.0, 0.001), Precision.EPSILON);
- assertEquals("atan2(-0.0, +Inf) should be -0.0", -0.0, FastMath.atan2(-0.1, Double.POSITIVE_INFINITY), Precision.EPSILON);
- assertEquals("atan2(0.0, -0.0) should be PI", FastMath.PI, FastMath.atan2(0.0, -0.0), Precision.EPSILON);
- assertEquals("atan2(0.1, -Inf) should be PI", FastMath.PI, FastMath.atan2(0.1, Double.NEGATIVE_INFINITY), Precision.EPSILON);
- assertEquals("atan2(-0.0, -0.0) should be -PI", -FastMath.PI, FastMath.atan2(-0.0, -0.0), Precision.EPSILON);
- assertEquals("atan2(0.1, -Inf) should be -PI", -FastMath.PI, FastMath.atan2(-0.1, Double.NEGATIVE_INFINITY), Precision.EPSILON);
- assertEquals("atan2(0.1, 0.0) should be PI/2", FastMath.PI / 2.0, FastMath.atan2(0.1, 0.0), Precision.EPSILON);
- assertEquals("atan2(0.1, -0.0) should be PI/2", FastMath.PI / 2.0, FastMath.atan2(0.1, -0.0), Precision.EPSILON);
- assertEquals("atan2(Inf, 0.1) should be PI/2", FastMath.PI / 2.0, FastMath.atan2(Double.POSITIVE_INFINITY, 0.1), Precision.EPSILON);
- assertEquals("atan2(Inf, -0.1) should be PI/2", FastMath.PI / 2.0, FastMath.atan2(Double.POSITIVE_INFINITY, -0.1), Precision.EPSILON);
- assertEquals("atan2(-0.1, 0.0) should be -PI/2", -FastMath.PI / 2.0, FastMath.atan2(-0.1, 0.0), Precision.EPSILON);
- assertEquals("atan2(-0.1, -0.0) should be -PI/2", -FastMath.PI / 2.0, FastMath.atan2(-0.1, -0.0), Precision.EPSILON);
- assertEquals("atan2(-Inf, 0.1) should be -PI/2", -FastMath.PI / 2.0, FastMath.atan2(Double.NEGATIVE_INFINITY, 0.1), Precision.EPSILON);
- assertEquals("atan2(-Inf, -0.1) should be -PI/2", -FastMath.PI / 2.0, FastMath.atan2(Double.NEGATIVE_INFINITY, -0.1), Precision.EPSILON);
- assertEquals("atan2(Inf, Inf) should be PI/4", FastMath.PI / 4.0, FastMath.atan2(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY),
+ assertTrue("atan2(NaN, 0.0) should be NaN", Double.isNaN(AccurateMath.atan2(Double.NaN, 0.0)));
+ assertTrue("atan2(0.0, NaN) should be NaN", Double.isNaN(AccurateMath.atan2(0.0, Double.NaN)));
+ assertEquals("atan2(0.0, 0.0) should be 0.0", 0.0, AccurateMath.atan2(0.0, 0.0), Precision.EPSILON);
+ assertEquals("atan2(0.0, 0.001) should be 0.0", 0.0, AccurateMath.atan2(0.0, 0.001), Precision.EPSILON);
+ assertEquals("atan2(0.1, +Inf) should be 0.0", 0.0, AccurateMath.atan2(0.1, Double.POSITIVE_INFINITY), Precision.EPSILON);
+ assertEquals("atan2(-0.0, 0.0) should be -0.0", -0.0, AccurateMath.atan2(-0.0, 0.0), Precision.EPSILON);
+ assertEquals("atan2(-0.0, 0.001) should be -0.0", -0.0, AccurateMath.atan2(-0.0, 0.001), Precision.EPSILON);
+ assertEquals("atan2(-0.0, +Inf) should be -0.0", -0.0, AccurateMath.atan2(-0.1, Double.POSITIVE_INFINITY), Precision.EPSILON);
+ assertEquals("atan2(0.0, -0.0) should be PI", AccurateMath.PI, AccurateMath.atan2(0.0, -0.0), Precision.EPSILON);
+ assertEquals("atan2(0.1, -Inf) should be PI", AccurateMath.PI, AccurateMath.atan2(0.1, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+ assertEquals("atan2(-0.0, -0.0) should be -PI", -AccurateMath.PI, AccurateMath.atan2(-0.0, -0.0), Precision.EPSILON);
+ assertEquals("atan2(0.1, -Inf) should be -PI", -AccurateMath.PI, AccurateMath.atan2(-0.1, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+ assertEquals("atan2(0.1, 0.0) should be PI/2", AccurateMath.PI / 2.0, AccurateMath.atan2(0.1, 0.0), Precision.EPSILON);
+ assertEquals("atan2(0.1, -0.0) should be PI/2", AccurateMath.PI / 2.0, AccurateMath.atan2(0.1, -0.0), Precision.EPSILON);
+ assertEquals("atan2(Inf, 0.1) should be PI/2", AccurateMath.PI / 2.0, AccurateMath.atan2(Double.POSITIVE_INFINITY, 0.1), Precision.EPSILON);
+ assertEquals("atan2(Inf, -0.1) should be PI/2", AccurateMath.PI / 2.0, AccurateMath.atan2(Double.POSITIVE_INFINITY, -0.1), Precision.EPSILON);
+ assertEquals("atan2(-0.1, 0.0) should be -PI/2", -AccurateMath.PI / 2.0, AccurateMath.atan2(-0.1, 0.0), Precision.EPSILON);
+ assertEquals("atan2(-0.1, -0.0) should be -PI/2", -AccurateMath.PI / 2.0, AccurateMath.atan2(-0.1, -0.0), Precision.EPSILON);
+ assertEquals("atan2(-Inf, 0.1) should be -PI/2", -AccurateMath.PI / 2.0, AccurateMath.atan2(Double.NEGATIVE_INFINITY, 0.1), Precision.EPSILON);
+ assertEquals("atan2(-Inf, -0.1) should be -PI/2", -AccurateMath.PI / 2.0, AccurateMath.atan2(Double.NEGATIVE_INFINITY, -0.1), Precision.EPSILON);
+ assertEquals("atan2(Inf, Inf) should be PI/4", AccurateMath.PI / 4.0, AccurateMath.atan2(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY),
Precision.EPSILON);
- assertEquals("atan2(Inf, -Inf) should be PI * 3/4", FastMath.PI * 3.0 / 4.0,
- FastMath.atan2(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
- assertEquals("atan2(-Inf, Inf) should be -PI/4", -FastMath.PI / 4.0, FastMath.atan2(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY),
+ assertEquals("atan2(Inf, -Inf) should be PI * 3/4", AccurateMath.PI * 3.0 / 4.0,
+ AccurateMath.atan2(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+ assertEquals("atan2(-Inf, Inf) should be -PI/4", -AccurateMath.PI / 4.0, AccurateMath.atan2(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY),
Precision.EPSILON);
- assertEquals("atan2(-Inf, -Inf) should be -PI * 3/4", - FastMath.PI * 3.0 / 4.0,
- FastMath.atan2(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
+ assertEquals("atan2(-Inf, -Inf) should be -PI * 3/4", - AccurateMath.PI * 3.0 / 4.0,
+ AccurateMath.atan2(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY), Precision.EPSILON);
}
@Test
@@ -653,14 +653,14 @@ public class FastMathTest {
double x = (generator.nextDouble() * 2.0 + 0.25);
double y = (generator.nextDouble() * 1200.0 - 600.0) * generator.nextDouble();
/*
- * double x = FastMath.floor(generator.nextDouble()*1024.0 - 512.0); double
- * y; if (x != 0) y = FastMath.floor(512.0 / FastMath.abs(x)); else
- * y = generator.nextDouble()*1200.0; y = y - y/2; x = FastMath.pow(2.0, x) *
+ * double x = AccurateMath.floor(generator.nextDouble()*1024.0 - 512.0); double
+ * y; if (x != 0) y = AccurateMath.floor(512.0 / AccurateMath.abs(x)); else
+ * y = generator.nextDouble()*1200.0; y = y - y/2; x = AccurateMath.pow(2.0, x) *
* generator.nextDouble(); y = y * generator.nextDouble();
*/
// double x = generator.nextDouble()*2.0;
- double tst = FastMath.pow(x, y);
+ double tst = AccurateMath.pow(x, y);
double ref = DfpMath.pow(field.newDfp(x), field.newDfp(y)).toDouble();
double err = (tst - ref) / ref;
@@ -687,7 +687,7 @@ public class FastMathTest {
// double x = (generator.nextDouble() * 20.0) - 10.0;
// double x = ((generator.nextDouble() * 2.0) - 1.0) * generator.nextDouble();
/* double x = 3.0 / 512.0 * i - 3.0; */
- double tst = FastMath.exp(x);
+ double tst = AccurateMath.exp(x);
double ref = DfpMath.exp(field.newDfp(x)).toDouble();
double err = (tst - ref) / ref;
@@ -716,7 +716,7 @@ public class FastMathTest {
// double x = (generator.nextDouble() * 20.0) - 10.0;
// double x = ((generator.nextDouble() * 2.0) - 1.0) * generator.nextDouble();
/* double x = 3.0 / 512.0 * i - 3.0; */
- double tst = FastMath.sin(x);
+ double tst = AccurateMath.sin(x);
double ref = DfpMath.sin(field.newDfp(x)).toDouble();
double err = (tst - ref) / ref;
@@ -745,7 +745,7 @@ public class FastMathTest {
// double x = (generator.nextDouble() * 20.0) - 10.0;
// double x = ((generator.nextDouble() * 2.0) - 1.0) * generator.nextDouble();
/* double x = 3.0 / 512.0 * i - 3.0; */
- double tst = FastMath.cos(x);
+ double tst = AccurateMath.cos(x);
double ref = DfpMath.cos(field.newDfp(x)).toDouble();
double err = (tst - ref) / ref;
@@ -774,7 +774,7 @@ public class FastMathTest {
// double x = (generator.nextDouble() * 20.0) - 10.0;
// double x = ((generator.nextDouble() * 2.0) - 1.0) * generator.nextDouble();
/* double x = 3.0 / 512.0 * i - 3.0; */
- double tst = FastMath.tan(x);
+ double tst = AccurateMath.tan(x);
double ref = DfpMath.tan(field.newDfp(x)).toDouble();
double err = (tst - ref) / ref;
@@ -805,7 +805,7 @@ public class FastMathTest {
// double x = (generator.nextDouble() * 20.0) - 10.0;
// double x = ((generator.nextDouble() * 2.0) - 1.0) * generator.nextDouble();
/* double x = 3.0 / 512.0 * i - 3.0; */
- double tst = FastMath.atan(x);
+ double tst = AccurateMath.atan(x);
double ref = DfpMath.atan(field.newDfp(x)).toDouble();
double err = (tst - ref) / ref;
@@ -834,7 +834,7 @@ public class FastMathTest {
// double x = (generator.nextDouble() * 20.0) - 10.0;
// double x = ((generator.nextDouble() * 2.0) - 1.0) * generator.nextDouble();
/* double x = 3.0 / 512.0 * i - 3.0; */
- double tst = FastMath.atan2(y, x);
+ double tst = AccurateMath.atan2(y, x);
Dfp refdfp = DfpMath.atan(field.newDfp(y).divide(field.newDfp(x)));
/* Make adjustments for sign */
if (x < 0.0) {
@@ -870,7 +870,7 @@ public class FastMathTest {
// double x = (generator.nextDouble() * 20.0) - 10.0;
double x = ((generator.nextDouble() * 16.0) - 8.0) * generator.nextDouble();
/* double x = 3.0 / 512.0 * i - 3.0; */
- double tst = FastMath.expm1(x);
+ double tst = AccurateMath.expm1(x);
double ref = DfpMath.exp(field.newDfp(x)).subtract(field.getOne()).toDouble();
double err = (tst - ref) / ref;
@@ -894,7 +894,7 @@ public class FastMathTest {
for (int i=0; i<10000; i++) {
double x = ((generator.nextDouble() * 2.0) - 1.0) * generator.nextDouble();
- double tst = FastMath.asin(x);
+ double tst = AccurateMath.asin(x);
double ref = DfpMath.asin(field.newDfp(x)).toDouble();
double err = (tst - ref) / ref;
@@ -917,7 +917,7 @@ public class FastMathTest {
for (int i=0; i<10000; i++) {
double x = ((generator.nextDouble() * 2.0) - 1.0) * generator.nextDouble();
- double tst = FastMath.acos(x);
+ double tst = AccurateMath.acos(x);
double ref = DfpMath.acos(field.newDfp(x)).toDouble();
double err = (tst - ref) / ref;
@@ -939,12 +939,12 @@ public class FastMathTest {
@Test
public void testAcosSpecialCases() {
- assertTrue("acos(NaN) should be NaN", Double.isNaN(FastMath.acos(Double.NaN)));
- assertTrue("acos(-1.1) should be NaN", Double.isNaN(FastMath.acos(-1.1)));
- assertTrue("acos(-1.1) should be NaN", Double.isNaN(FastMath.acos(1.1)));
- assertEquals("acos(-1.0) should be PI", FastMath.acos(-1.0), FastMath.PI, Precision.EPSILON);
- assertEquals("acos(1.0) should be 0.0", FastMath.acos(1.0), 0.0, Precision.EPSILON);
- assertEquals("acos(0.0) should be PI/2", FastMath.acos(0.0), FastMath.PI / 2.0, Precision.EPSILON);
+ assertTrue("acos(NaN) should be NaN", Double.isNaN(AccurateMath.acos(Double.NaN)));
+ assertTrue("acos(-1.1) should be NaN", Double.isNaN(AccurateMath.acos(-1.1)));
+ assertTrue("acos(-1.1) should be NaN", Double.isNaN(AccurateMath.acos(1.1)));
+ assertEquals("acos(-1.0) should be PI", AccurateMath.acos(-1.0), AccurateMath.PI, Precision.EPSILON);
+ assertEquals("acos(1.0) should be 0.0", AccurateMath.acos(1.0), 0.0, Precision.EPSILON);
+ assertEquals("acos(0.0) should be PI/2", AccurateMath.acos(0.0), AccurateMath.PI / 2.0, Precision.EPSILON);
}
/**
@@ -953,12 +953,12 @@ public class FastMathTest {
@Test
public void testAsinSpecialCases() {
- assertTrue("asin(NaN) should be NaN", Double.isNaN(FastMath.asin(Double.NaN)));
- assertTrue("asin(1.1) should be NaN", Double.isNaN(FastMath.asin(1.1)));
- assertTrue("asin(-1.1) should be NaN", Double.isNaN(FastMath.asin(-1.1)));
- assertEquals("asin(1.0) should be PI/2", FastMath.asin(1.0), FastMath.PI / 2.0, Precision.EPSILON);
- assertEquals("asin(-1.0) should be -PI/2", FastMath.asin(-1.0), -FastMath.PI / 2.0, Precision.EPSILON);
- assertEquals("asin(0.0) should be 0.0", FastMath.asin(0.0), 0.0, Precision.EPSILON);
+ assertTrue("asin(NaN) should be NaN", Double.isNaN(AccurateMath.asin(Double.NaN)));
+ assertTrue("asin(1.1) should be NaN", Double.isNaN(AccurateMath.asin(1.1)));
+ assertTrue("asin(-1.1) should be NaN", Double.isNaN(AccurateMath.asin(-1.1)));
+ assertEquals("asin(1.0) should be PI/2", AccurateMath.asin(1.0), AccurateMath.PI / 2.0, Precision.EPSILON);
+ assertEquals("asin(-1.0) should be -PI/2", AccurateMath.asin(-1.0), -AccurateMath.PI / 2.0, Precision.EPSILON);
+ assertEquals("asin(0.0) should be 0.0", AccurateMath.asin(0.0), 0.0, Precision.EPSILON);
}
private Dfp cosh(Dfp x) {
@@ -980,7 +980,7 @@ public class FastMathTest {
for (int i=0; i<10000; i++) {
double x = ((generator.nextDouble() * 16.0) - 8.0) * generator.nextDouble();
- double tst = FastMath.sinh(x);
+ double tst = AccurateMath.sinh(x);
double ref = sinh(field.newDfp(x)).toDouble();
double err = (tst - ref) / ref;
@@ -1002,7 +1002,7 @@ public class FastMathTest {
for (int i=0; i<10000; i++) {
double x = ((generator.nextDouble() * 16.0) - 8.0) * generator.nextDouble();
- double tst = FastMath.cosh(x);
+ double tst = AccurateMath.cosh(x);
double ref = cosh(field.newDfp(x)).toDouble();
double err = (tst - ref) / ref;
@@ -1024,7 +1024,7 @@ public class FastMathTest {
for (int i=0; i<10000; i++) {
double x = ((generator.nextDouble() * 16.0) - 8.0) * generator.nextDouble();
- double tst = FastMath.tanh(x);
+ double tst = AccurateMath.tanh(x);
double ref = tanh(field.newDfp(x)).toDouble();
double err = (tst - ref) / ref;
@@ -1046,7 +1046,7 @@ public class FastMathTest {
for (int i=0; i<10000; i++) {
double x = ((generator.nextDouble() * 200.0) - 100.0) * generator.nextDouble();
- double tst = FastMath.cbrt(x);
+ double tst = AccurateMath.cbrt(x);
double ref = cbrt(field.newDfp(x)).toDouble();
double err = (tst - ref) / ref;
@@ -1084,7 +1084,7 @@ public class FastMathTest {
for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
double x = generator.nextDouble();
double tst = field.newDfp(x).multiply(180).divide(field.getPi()).toDouble();
- double ref = FastMath.toDegrees(x);
+ double ref = AccurateMath.toDegrees(x);
double err = (tst - ref) / ref;
if (err != 0) {
@@ -1105,7 +1105,7 @@ public class FastMathTest {
for (int i = 0; i < NUMBER_OF_TRIALS; i++) {
double x = generator.nextDouble();
double tst = field.newDfp(x).multiply(field.getPi()).divide(180).toDouble();
- double ref = FastMath.toRadians(x);
+ double ref = AccurateMath.toRadians(x);
double err = (tst - ref) / ref;
if (err != 0) {
@@ -1124,133 +1124,133 @@ public class FastMathTest {
@Test
public void testNextAfter() {
// 0x402fffffffffffff 0x404123456789abcd -> 4030000000000000
- assertEquals(16.0, FastMath.nextUp(15.999999999999998), 0.0);
+ assertEquals(16.0, AccurateMath.nextUp(15.999999999999998), 0.0);
// 0xc02fffffffffffff 0x404123456789abcd -> c02ffffffffffffe
- assertEquals(-15.999999999999996, FastMath.nextAfter(-15.999999999999998, 34.27555555555555), 0.0);
+ assertEquals(-15.999999999999996, AccurateMath.nextAfter(-15.999999999999998, 34.27555555555555), 0.0);
// 0x402fffffffffffff 0x400123456789abcd -> 402ffffffffffffe
- assertEquals(15.999999999999996, FastMath.nextDown(15.999999999999998), 0.0);
+ assertEquals(15.999999999999996, AccurateMath.nextDown(15.999999999999998), 0.0);
// 0xc02fffffffffffff 0x400123456789abcd -> c02ffffffffffffe
- assertEquals(-15.999999999999996, FastMath.nextAfter(-15.999999999999998, 2.142222222222222), 0.0);
+ assertEquals(-15.999999999999996, AccurateMath.nextAfter(-15.999999999999998, 2.142222222222222), 0.0);
// 0x4020000000000000 0x404123456789abcd -> 4020000000000001
- assertEquals(8.000000000000002, FastMath.nextAfter(8.0, 34.27555555555555), 0.0);
+ assertEquals(8.000000000000002, AccurateMath.nextAfter(8.0, 34.27555555555555), 0.0);
// 0xc020000000000000 0x404123456789abcd -> c01fffffffffffff
- assertEquals(-7.999999999999999, FastMath.nextAfter(-8.0, 34.27555555555555), 0.0);
+ assertEquals(-7.999999999999999, AccurateMath.nextAfter(-8.0, 34.27555555555555), 0.0);
// 0x4020000000000000 0x400123456789abcd -> 401fffffffffffff
- assertEquals(7.999999999999999, FastMath.nextAfter(8.0, 2.142222222222222), 0.0);
+ assertEquals(7.999999999999999, AccurateMath.nextAfter(8.0, 2.142222222222222), 0.0);
// 0xc020000000000000 0x400123456789abcd -> c01fffffffffffff
- assertEquals(-7.999999999999999, FastMath.nextAfter(-8.0, 2.142222222222222), 0.0);
+ assertEquals(-7.999999999999999, AccurateMath.nextAfter(-8.0, 2.142222222222222), 0.0);
// 0x3f2e43753d36a223 0x3f2e43753d36a224 -> 3f2e43753d36a224
- assertEquals(2.308922399667661E-4, FastMath.nextAfter(2.3089223996676606E-4, 2.308922399667661E-4), 0.0);
+ assertEquals(2.308922399667661E-4, AccurateMath.nextAfter(2.3089223996676606E-4, 2.308922399667661E-4), 0.0);
// 0x3f2e43753d36a223 0x3f2e43753d36a223 -> 3f2e43753d36a223
- assertEquals(2.3089223996676606E-4, FastMath.nextAfter(2.3089223996676606E-4, 2.3089223996676606E-4), 0.0);
+ assertEquals(2.3089223996676606E-4, AccurateMath.nextAfter(2.3089223996676606E-4, 2.3089223996676606E-4), 0.0);
// 0x3f2e43753d36a223 0x3f2e43753d36a222 -> 3f2e43753d36a222
- assertEquals(2.3089223996676603E-4, FastMath.nextAfter(2.3089223996676606E-4, 2.3089223996676603E-4), 0.0);
+ assertEquals(2.3089223996676603E-4, AccurateMath.nextAfter(2.3089223996676606E-4, 2.3089223996676603E-4), 0.0);
// 0x3f2e43753d36a223 0xbf2e43753d36a224 -> 3f2e43753d36a222
- assertEquals(2.3089223996676603E-4, FastMath.nextAfter(2.3089223996676606E-4, -2.308922399667661E-4), 0.0);
+ assertEquals(2.3089223996676603E-4, AccurateMath.nextAfter(2.3089223996676606E-4, -2.308922399667661E-4), 0.0);
// 0x3f2e43753d36a223 0xbf2e43753d36a223 -> 3f2e43753d36a222
- assertEquals(2.3089223996676603E-4, FastMath.nextAfter(2.3089223996676606E-4, -2.3089223996676606E-4), 0.0);
+ assertEquals(2.3089223996676603E-4, AccurateMath.nextAfter(2.3089223996676606E-4, -2.3089223996676606E-4), 0.0);
// 0x3f2e43753d36a223 0xbf2e43753d36a222 -> 3f2e43753d36a222
- assertEquals(2.3089223996676603E-4, FastMath.nextAfter(2.3089223996676606E-4, -2.3089223996676603E-4), 0.0);
+ assertEquals(2.3089223996676603E-4, AccurateMath.nextAfter(2.3089223996676606E-4, -2.3089223996676603E-4), 0.0);
// 0xbf2e43753d36a223 0x3f2e43753d36a224 -> bf2e43753d36a222
- assertEquals(-2.3089223996676603E-4, FastMath.nextAfter(-2.3089223996676606E-4, 2.308922399667661E-4), 0.0);
+ assertEquals(-2.3089223996676603E-4, AccurateMath.nextAfter(-2.3089223996676606E-4, 2.308922399667661E-4), 0.0);
// 0xbf2e43753d36a223 0x3f2e43753d36a223 -> bf2e43753d36a222
- assertEquals(-2.3089223996676603E-4, FastMath.nextAfter(-2.3089223996676606E-4, 2.3089223996676606E-4), 0.0);
+ assertEquals(-2.3089223996676603E-4, AccurateMath.nextAfter(-2.3089223996676606E-4, 2.3089223996676606E-4), 0.0);
// 0xbf2e43753d36a223 0x3f2e43753d36a222 -> bf2e43753d36a222
- assertEquals(-2.3089223996676603E-4, FastMath.nextAfter(-2.3089223996676606E-4, 2.3089223996676603E-4), 0.0);
+ assertEquals(-2.3089223996676603E-4, AccurateMath.nextAfter(-2.3089223996676606E-4, 2.3089223996676603E-4), 0.0);
// 0xbf2e43753d36a223 0xbf2e43753d36a224 -> bf2e43753d36a224
- assertEquals(-2.308922399667661E-4, FastMath.nextAfter(-2.3089223996676606E-4, -2.308922399667661E-4), 0.0);
+ assertEquals(-2.308922399667661E-4, AccurateMath.nextAfter(-2.3089223996676606E-4, -2.308922399667661E-4), 0.0);
// 0xbf2e43753d36a223 0xbf2e43753d36a223 -> bf2e43753d36a223
- assertEquals(-2.3089223996676606E-4, FastMath.nextAfter(-2.3089223996676606E-4, -2.3089223996676606E-4), 0.0);
+ assertEquals(-2.3089223996676606E-4, AccurateMath.nextAfter(-2.3089223996676606E-4, -2.3089223996676606E-4), 0.0);
// 0xbf2e43753d36a223 0xbf2e43753d36a222 -> bf2e43753d36a222
- assertEquals(-2.3089223996676603E-4, FastMath.nextAfter(-2.3089223996676606E-4, -2.3089223996676603E-4), 0.0);
+ assertEquals(-2.3089223996676603E-4, AccurateMath.nextAfter(-2.3089223996676606E-4, -2.3089223996676603E-4), 0.0);
}
@Test
public void testDoubleNextAfterSpecialCases() {
- assertEquals(-Double.MAX_VALUE,FastMath.nextAfter(Double.NEGATIVE_INFINITY, 0D), 0D);
- assertEquals(Double.MAX_VALUE,FastMath.nextAfter(Double.POSITIVE_INFINITY, 0D), 0D);
- assertEquals(Double.NaN,FastMath.nextAfter(Double.NaN, 0D), 0D);
- assertEquals(Double.POSITIVE_INFINITY,FastMath.nextAfter(Double.MAX_VALUE, Double.POSITIVE_INFINITY), 0D);
- assertEquals(Double.NEGATIVE_INFINITY,FastMath.nextAfter(-Double.MAX_VALUE, Double.NEGATIVE_INFINITY), 0D);
- assertEquals(Double.MIN_VALUE, FastMath.nextAfter(0D, 1D), 0D);
- assertEquals(-Double.MIN_VALUE, FastMath.nextAfter(0D, -1D), 0D);
- assertEquals(0D, FastMath.nextAfter(Double.MIN_VALUE, -1), 0D);
- assertEquals(0D, FastMath.nextAfter(-Double.MIN_VALUE, 1), 0D);
+ assertEquals(-Double.MAX_VALUE,AccurateMath.nextAfter(Double.NEGATIVE_INFINITY, 0D), 0D);
+ assertEquals(Double.MAX_VALUE,AccurateMath.nextAfter(Double.POSITIVE_INFINITY, 0D), 0D);
+ assertEquals(Double.NaN,AccurateMath.nextAfter(Double.NaN, 0D), 0D);
+ assertEquals(Double.POSITIVE_INFINITY,AccurateMath.nextAfter(Double.MAX_VALUE, Double.POSITIVE_INFINITY), 0D);
+ assertEquals(Double.NEGATIVE_INFINITY,AccurateMath.nextAfter(-Double.MAX_VALUE, Double.NEGATIVE_INFINITY), 0D);
+ assertEquals(Double.MIN_VALUE, AccurateMath.nextAfter(0D, 1D), 0D);
+ assertEquals(-Double.MIN_VALUE, AccurateMath.nextAfter(0D, -1D), 0D);
+ assertEquals(0D, AccurateMath.nextAfter(Double.MIN_VALUE, -1), 0D);
+ assertEquals(0D, AccurateMath.nextAfter(-Double.MIN_VALUE, 1), 0D);
}
@Test
public void testFloatNextAfterSpecialCases() {
- assertEquals(-Float.MAX_VALUE, FastMath.nextAfter(Float.NEGATIVE_INFINITY, 0F), 0F);
- assertEquals(Float.MAX_VALUE, FastMath.nextAfter(Float.POSITIVE_INFINITY, 0F), 0F);
- assertEquals(Float.NaN, FastMath.nextAfter(Float.NaN, 0F), 0F);
- assertEquals(Float.POSITIVE_INFINITY, FastMath.nextUp(Float.MAX_VALUE), 0F);
- assertEquals(Float.NEGATIVE_INFINITY, FastMath.nextDown(-Float.MAX_VALUE), 0F);
- assertEquals(Float.MIN_VALUE, FastMath.nextAfter(0F, 1F), 0F);
- assertEquals(-Float.MIN_VALUE, FastMath.nextAfter(0F, -1F), 0F);
- assertEquals(0F, FastMath.nextAfter(Float.MIN_VALUE, -1F), 0F);
- assertEquals(0F, FastMath.nextAfter(-Float.MIN_VALUE, 1F), 0F);
+ assertEquals(-Float.MAX_VALUE, AccurateMath.nextAfter(Float.NEGATIVE_INFINITY, 0F), 0F);
+ assertEquals(Float.MAX_VALUE, AccurateMath.nextAfter(Float.POSITIVE_INFINITY, 0F), 0F);
+ assertEquals(Float.NaN, AccurateMath.nextAfter(Float.NaN, 0F), 0F);
+ assertEquals(Float.POSITIVE_INFINITY, AccurateMath.nextUp(Float.MAX_VALUE), 0F);
+ assertEquals(Float.NEGATIVE_INFINITY, AccurateMath.nextDown(-Float.MAX_VALUE), 0F);
+ assertEquals(Float.MIN_VALUE, AccurateMath.nextAfter(0F, 1F), 0F);
+ assertEquals(-Float.MIN_VALUE, AccurateMath.nextAfter(0F, -1F), 0F);
+ assertEquals(0F, AccurateMath.nextAfter(Float.MIN_VALUE, -1F), 0F);
+ assertEquals(0F, AccurateMath.nextAfter(-Float.MIN_VALUE, 1F), 0F);
}
@Test
public void testDoubleScalbSpecialCases() {
- assertEquals(2.5269841324701218E-175, FastMath.scalb(2.2250738585072014E-308, 442), 0D);
- assertEquals(1.307993905256674E297, FastMath.scalb(1.1102230246251565E-16, 1040), 0D);
- assertEquals(7.2520887996488946E-217, FastMath.scalb(Double.MIN_VALUE, 356), 0D);
- assertEquals(8.98846567431158E307, FastMath.scalb(Double.MIN_VALUE, 2097), 0D);
- assertEquals(Double.POSITIVE_INFINITY, FastMath.scalb(Double.MIN_VALUE, 2098), 0D);
- assertEquals(1.1125369292536007E-308, FastMath.scalb(2.225073858507201E-308, -1), 0D);
- assertEquals(1.0E-323, FastMath.scalb(Double.MAX_VALUE, -2097), 0D);
- assertEquals(Double.MIN_VALUE, FastMath.scalb(Double.MAX_VALUE, -2098), 0D);
- assertEquals(0, FastMath.scalb(Double.MAX_VALUE, -2099), 0D);
- assertEquals(Double.POSITIVE_INFINITY, FastMath.scalb(Double.POSITIVE_INFINITY, -1000000), 0D);
- assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-1.1102230246251565E-16, 1078), 0D);
- assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-1.1102230246251565E-16, 1079), 0D);
- assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-2.2250738585072014E-308, 2047), 0D);
- assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-2.2250738585072014E-308, 2048), 0D);
- assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-1.7976931348623157E308, 2147483647), 0D);
- assertEquals(Double.POSITIVE_INFINITY, FastMath.scalb( 1.7976931348623157E308, 2147483647), 0D);
- assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-1.1102230246251565E-16, 2147483647), 0D);
- assertEquals(Double.POSITIVE_INFINITY, FastMath.scalb( 1.1102230246251565E-16, 2147483647), 0D);
- assertEquals(Double.NEGATIVE_INFINITY, FastMath.scalb(-2.2250738585072014E-308, 2147483647), 0D);
- assertEquals(Double.POSITIVE_INFINITY, FastMath.scalb( 2.2250738585072014E-308, 2147483647), 0D);
+ assertEquals(2.5269841324701218E-175, AccurateMath.scalb(2.2250738585072014E-308, 442), 0D);
+ assertEquals(1.307993905256674E297, AccurateMath.scalb(1.1102230246251565E-16, 1040), 0D);
+ assertEquals(7.2520887996488946E-217, AccurateMath.scalb(Double.MIN_VALUE, 356), 0D);
+ assertEquals(8.98846567431158E307, AccurateMath.scalb(Double.MIN_VALUE, 2097), 0D);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.scalb(Double.MIN_VALUE, 2098), 0D);
+ assertEquals(1.1125369292536007E-308, AccurateMath.scalb(2.225073858507201E-308, -1), 0D);
+ assertEquals(1.0E-323, AccurateMath.scalb(Double.MAX_VALUE, -2097), 0D);
+ assertEquals(Double.MIN_VALUE, AccurateMath.scalb(Double.MAX_VALUE, -2098), 0D);
+ assertEquals(0, AccurateMath.scalb(Double.MAX_VALUE, -2099), 0D);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.scalb(Double.POSITIVE_INFINITY, -1000000), 0D);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.scalb(-1.1102230246251565E-16, 1078), 0D);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.scalb(-1.1102230246251565E-16, 1079), 0D);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.scalb(-2.2250738585072014E-308, 2047), 0D);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.scalb(-2.2250738585072014E-308, 2048), 0D);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.scalb(-1.7976931348623157E308, 2147483647), 0D);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.scalb( 1.7976931348623157E308, 2147483647), 0D);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.scalb(-1.1102230246251565E-16, 2147483647), 0D);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.scalb( 1.1102230246251565E-16, 2147483647), 0D);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.scalb(-2.2250738585072014E-308, 2147483647), 0D);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.scalb( 2.2250738585072014E-308, 2147483647), 0D);
}
@Test
public void testFloatScalbSpecialCases() {
- assertEquals(0f, FastMath.scalb(Float.MIN_VALUE, -30), 0F);
- assertEquals(2 * Float.MIN_VALUE, FastMath.scalb(Float.MIN_VALUE, 1), 0F);
- assertEquals(7.555786e22f, FastMath.scalb(Float.MAX_VALUE, -52), 0F);
- assertEquals(1.7014118e38f, FastMath.scalb(Float.MIN_VALUE, 276), 0F);
- assertEquals(Float.POSITIVE_INFINITY, FastMath.scalb(Float.MIN_VALUE, 277), 0F);
- assertEquals(5.8774718e-39f, FastMath.scalb(1.1754944e-38f, -1), 0F);
- assertEquals(2 * Float.MIN_VALUE, FastMath.scalb(Float.MAX_VALUE, -276), 0F);
- assertEquals(Float.MIN_VALUE, FastMath.scalb(Float.MAX_VALUE, -277), 0F);
- assertEquals(0, FastMath.scalb(Float.MAX_VALUE, -278), 0F);
- assertEquals(Float.POSITIVE_INFINITY, FastMath.scalb(Float.POSITIVE_INFINITY, -1000000), 0F);
- assertEquals(-3.13994498e38f, FastMath.scalb(-1.1e-7f, 151), 0F);
- assertEquals(Float.NEGATIVE_INFINITY, FastMath.scalb(-1.1e-7f, 152), 0F);
- assertEquals(Float.POSITIVE_INFINITY, FastMath.scalb(3.4028235E38f, 2147483647), 0F);
- assertEquals(Float.NEGATIVE_INFINITY, FastMath.scalb(-3.4028235E38f, 2147483647), 0F);
+ assertEquals(0f, AccurateMath.scalb(Float.MIN_VALUE, -30), 0F);
+ assertEquals(2 * Float.MIN_VALUE, AccurateMath.scalb(Float.MIN_VALUE, 1), 0F);
+ assertEquals(7.555786e22f, AccurateMath.scalb(Float.MAX_VALUE, -52), 0F);
+ assertEquals(1.7014118e38f, AccurateMath.scalb(Float.MIN_VALUE, 276), 0F);
+ assertEquals(Float.POSITIVE_INFINITY, AccurateMath.scalb(Float.MIN_VALUE, 277), 0F);
+ assertEquals(5.8774718e-39f, AccurateMath.scalb(1.1754944e-38f, -1), 0F);
+ assertEquals(2 * Float.MIN_VALUE, AccurateMath.scalb(Float.MAX_VALUE, -276), 0F);
+ assertEquals(Float.MIN_VALUE, AccurateMath.scalb(Float.MAX_VALUE, -277), 0F);
+ assertEquals(0, AccurateMath.scalb(Float.MAX_VALUE, -278), 0F);
+ assertEquals(Float.POSITIVE_INFINITY, AccurateMath.scalb(Float.POSITIVE_INFINITY, -1000000), 0F);
+ assertEquals(-3.13994498e38f, AccurateMath.scalb(-1.1e-7f, 151), 0F);
+ assertEquals(Float.NEGATIVE_INFINITY, AccurateMath.scalb(-1.1e-7f, 152), 0F);
+ assertEquals(Float.POSITIVE_INFINITY, AccurateMath.scalb(3.4028235E38f, 2147483647), 0F);
+ assertEquals(Float.NEGATIVE_INFINITY, AccurateMath.scalb(-3.4028235E38f, 2147483647), 0F);
}
private boolean compareClassMethods(Class class1, Class class2){
@@ -1270,68 +1270,68 @@ public class FastMathTest {
}
@Test
- public void checkMissingFastMathClasses() {
- boolean ok = compareClassMethods(StrictMath.class, FastMath.class);
- assertTrue("FastMath should implement all StrictMath methods", ok);
+ public void checkMissingAccurateMathClasses() {
+ boolean ok = compareClassMethods(StrictMath.class, AccurateMath.class);
+ assertTrue("AccurateMath should implement all StrictMath methods", ok);
}
@Ignore
@Test
- public void checkExtraFastMathClasses() {
- compareClassMethods(FastMath.class, StrictMath.class);
+ public void checkExtraAccurateMathClasses() {
+ compareClassMethods(AccurateMath.class, StrictMath.class);
}
@Test
public void testSignumDouble() {
final double delta = 0.0;
- assertEquals(1.0, FastMath.signum(2.0), delta);
- assertEquals(0.0, FastMath.signum(0.0), delta);
- assertEquals(-1.0, FastMath.signum(-2.0), delta);
- TestUtils.assertSame(-0. / 0., FastMath.signum(Double.NaN));
+ assertEquals(1.0, AccurateMath.signum(2.0), delta);
+ assertEquals(0.0, AccurateMath.signum(0.0), delta);
+ assertEquals(-1.0, AccurateMath.signum(-2.0), delta);
+ TestUtils.assertSame(-0. / 0., AccurateMath.signum(Double.NaN));
}
@Test
public void testSignumFloat() {
final float delta = 0.0F;
- assertEquals(1.0F, FastMath.signum(2.0F), delta);
- assertEquals(0.0F, FastMath.signum(0.0F), delta);
- assertEquals(-1.0F, FastMath.signum(-2.0F), delta);
- TestUtils.assertSame(Float.NaN, FastMath.signum(Float.NaN));
+ assertEquals(1.0F, AccurateMath.signum(2.0F), delta);
+ assertEquals(0.0F, AccurateMath.signum(0.0F), delta);
+ assertEquals(-1.0F, AccurateMath.signum(-2.0F), delta);
+ TestUtils.assertSame(Float.NaN, AccurateMath.signum(Float.NaN));
}
@Test
public void testLogWithBase() {
- assertEquals(2.0, FastMath.log(2, 4), 0);
- assertEquals(3.0, FastMath.log(2, 8), 0);
- assertTrue(Double.isNaN(FastMath.log(-1, 1)));
- assertTrue(Double.isNaN(FastMath.log(1, -1)));
- assertTrue(Double.isNaN(FastMath.log(0, 0)));
- assertEquals(0, FastMath.log(0, 10), 0);
- assertEquals(Double.NEGATIVE_INFINITY, FastMath.log(10, 0), 0);
+ assertEquals(2.0, AccurateMath.log(2, 4), 0);
+ assertEquals(3.0, AccurateMath.log(2, 8), 0);
+ assertTrue(Double.isNaN(AccurateMath.log(-1, 1)));
+ assertTrue(Double.isNaN(AccurateMath.log(1, -1)));
+ assertTrue(Double.isNaN(AccurateMath.log(0, 0)));
+ assertEquals(0, AccurateMath.log(0, 10), 0);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.log(10, 0), 0);
}
@Test
public void testIndicatorDouble() {
double delta = 0.0;
- assertEquals(1.0, FastMath.copySign(1d, 2.0), delta);
- assertEquals(1.0, FastMath.copySign(1d, 0.0), delta);
- assertEquals(-1.0, FastMath.copySign(1d, -0.0), delta);
- assertEquals(1.0, FastMath.copySign(1d, Double.POSITIVE_INFINITY), delta);
- assertEquals(-1.0, FastMath.copySign(1d, Double.NEGATIVE_INFINITY), delta);
- assertEquals(1.0, FastMath.copySign(1d, Double.NaN), delta);
- assertEquals(-1.0, FastMath.copySign(1d, -2.0), delta);
+ assertEquals(1.0, AccurateMath.copySign(1d, 2.0), delta);
+ assertEquals(1.0, AccurateMath.copySign(1d, 0.0), delta);
+ assertEquals(-1.0, AccurateMath.copySign(1d, -0.0), delta);
+ assertEquals(1.0, AccurateMath.copySign(1d, Double.POSITIVE_INFINITY), delta);
+ assertEquals(-1.0, AccurateMath.copySign(1d, Double.NEGATIVE_INFINITY), delta);
+ assertEquals(1.0, AccurateMath.copySign(1d, Double.NaN), delta);
+ assertEquals(-1.0, AccurateMath.copySign(1d, -2.0), delta);
}
@Test
public void testIndicatorFloat() {
float delta = 0.0F;
- assertEquals(1.0F, FastMath.copySign(1d, 2.0F), delta);
- assertEquals(1.0F, FastMath.copySign(1d, 0.0F), delta);
- assertEquals(-1.0F, FastMath.copySign(1d, -0.0F), delta);
- assertEquals(1.0F, FastMath.copySign(1d, Float.POSITIVE_INFINITY), delta);
- assertEquals(-1.0F, FastMath.copySign(1d, Float.NEGATIVE_INFINITY), delta);
- assertEquals(1.0F, FastMath.copySign(1d, Float.NaN), delta);
- assertEquals(-1.0F, FastMath.copySign(1d, -2.0F), delta);
+ assertEquals(1.0F, AccurateMath.copySign(1d, 2.0F), delta);
+ assertEquals(1.0F, AccurateMath.copySign(1d, 0.0F), delta);
+ assertEquals(-1.0F, AccurateMath.copySign(1d, -0.0F), delta);
+ assertEquals(1.0F, AccurateMath.copySign(1d, Float.POSITIVE_INFINITY), delta);
+ assertEquals(-1.0F, AccurateMath.copySign(1d, Float.NEGATIVE_INFINITY), delta);
+ assertEquals(1.0F, AccurateMath.copySign(1d, Float.NaN), delta);
+ assertEquals(-1.0F, AccurateMath.copySign(1d, -2.0F), delta);
}
@Test
@@ -1342,20 +1342,20 @@ public class FastMathTest {
Dfp baseDfp = field.newDfp(base);
Dfp dfpPower = field.getOne();
for (int i = 0; i < maxExp; i++) {
- assertEquals("exp=" + i, dfpPower.toDouble(), FastMath.pow(base, i),
- 0.6 * FastMath.ulp(dfpPower.toDouble()));
+ assertEquals("exp=" + i, dfpPower.toDouble(), AccurateMath.pow(base, i),
+ 0.6 * AccurateMath.ulp(dfpPower.toDouble()));
dfpPower = dfpPower.multiply(baseDfp);
}
}
@Test
public void testIntPowHuge() {
- assertTrue(Double.isInfinite(FastMath.pow(FastMath.scalb(1.0, 500), 4)));
+ assertTrue(Double.isInfinite(AccurateMath.pow(AccurateMath.scalb(1.0, 500), 4)));
}
@Test(timeout=5000L) // This test must finish in finite time.
public void testIntPowLongMinValue() {
- assertEquals(1.0, FastMath.pow(1.0, Long.MIN_VALUE), -1.0);
+ assertEquals(1.0, AccurateMath.pow(1.0, Long.MIN_VALUE), -1.0);
}
@Test(timeout=5000L)
@@ -1378,63 +1378,63 @@ public class FastMathTest {
// Special cases from Math.pow javadoc:
// If the second argument is positive or negative zero, then the result is 1.0.
for (double d : DOUBLES) {
- assertEquals(1.0, FastMath.pow(d, 0L), EXACT);
+ assertEquals(1.0, AccurateMath.pow(d, 0L), EXACT);
}
// If the second argument is 1.0, then the result is the same as the first argument.
for (double d : DOUBLES) {
- assertEquals(d, FastMath.pow(d, 1L), EXACT);
+ assertEquals(d, AccurateMath.pow(d, 1L), EXACT);
}
// If the second argument is NaN, then the result is NaN. <- Impossible with int.
// If the first argument is NaN and the second argument is nonzero, then the result is NaN.
for (long i : INTS) {
if (i != 0L) {
- assertEquals(Double.NaN, FastMath.pow(Double.NaN, i), EXACT);
+ assertEquals(Double.NaN, AccurateMath.pow(Double.NaN, i), EXACT);
}
}
// If the absolute value of the first argument is greater than 1 and the second argument is positive infinity, or
// the absolute value of the first argument is less than 1 and the second argument is negative infinity, then the result is positive infinity.
for (double d : DOUBLES) {
if (Math.abs(d) > 1.0) {
- assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(d, Long.MAX_VALUE - 1L), EXACT);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(d, Long.MAX_VALUE - 1L), EXACT);
}
}
for (double d : DOUBLES) {
if (Math.abs(d) < 1.0) {
- assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(d, Long.MIN_VALUE), EXACT);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(d, Long.MIN_VALUE), EXACT);
}
}
// Note: Long.MAX_VALUE isn't actually an infinity, so its parity affects the sign of resulting infinity.
for (double d : DOUBLES) {
if (Math.abs(d) > 1.0) {
- assertTrue(Double.isInfinite(FastMath.pow(d, Long.MAX_VALUE)));
+ assertTrue(Double.isInfinite(AccurateMath.pow(d, Long.MAX_VALUE)));
}
}
for (double d : DOUBLES) {
if (Math.abs(d) < 1.0) {
- assertTrue(Double.isInfinite(FastMath.pow(d, Long.MIN_VALUE + 1L)));
+ assertTrue(Double.isInfinite(AccurateMath.pow(d, Long.MIN_VALUE + 1L)));
}
}
// If the absolute value of the first argument is greater than 1 and the second argument is negative infinity, or
// the absolute value of the first argument is less than 1 and the second argument is positive infinity, then the result is positive zero.
for (double d : DOUBLES) {
if (Math.abs(d) > 1.0) {
- assertEquals(0.0, FastMath.pow(d, Long.MIN_VALUE), EXACT);
+ assertEquals(0.0, AccurateMath.pow(d, Long.MIN_VALUE), EXACT);
}
}
for (double d : DOUBLES) {
if (Math.abs(d) < 1.0) {
- assertEquals(0.0, FastMath.pow(d, Long.MAX_VALUE - 1L), EXACT);
+ assertEquals(0.0, AccurateMath.pow(d, Long.MAX_VALUE - 1L), EXACT);
}
}
// Note: Long.MAX_VALUE isn't actually an infinity, so its parity affects the sign of resulting zero.
for (double d : DOUBLES) {
if (Math.abs(d) > 1.0) {
- assertTrue(FastMath.pow(d, Long.MIN_VALUE + 1L) == 0.0);
+ assertTrue(AccurateMath.pow(d, Long.MIN_VALUE + 1L) == 0.0);
}
}
for (double d : DOUBLES) {
if (Math.abs(d) < 1.0) {
- assertTrue(FastMath.pow(d, Long.MAX_VALUE) == 0.0);
+ assertTrue(AccurateMath.pow(d, Long.MAX_VALUE) == 0.0);
}
}
// If the absolute value of the first argument equals 1 and the second argument is infinite, then the result is NaN. <- Impossible with int.
@@ -1442,72 +1442,72 @@ public class FastMathTest {
// the first argument is positive infinity and the second argument is less than zero, then the result is positive zero.
for (long i : INTS) {
if (i > 0L) {
- assertEquals(0.0, FastMath.pow(0.0, i), EXACT);
+ assertEquals(0.0, AccurateMath.pow(0.0, i), EXACT);
}
}
for (long i : INTS) {
if (i < 0L) {
- assertEquals(0.0, FastMath.pow(Double.POSITIVE_INFINITY, i), EXACT);
+ assertEquals(0.0, AccurateMath.pow(Double.POSITIVE_INFINITY, i), EXACT);
}
}
// If the first argument is positive zero and the second argument is less than zero, or
// the first argument is positive infinity and the second argument is greater than zero, then the result is positive infinity.
for (long i : INTS) {
if (i < 0L) {
- assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(0.0, i), EXACT);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(0.0, i), EXACT);
}
}
for (long i : INTS) {
if (i > 0L) {
- assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(Double.POSITIVE_INFINITY, i), EXACT);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(Double.POSITIVE_INFINITY, i), EXACT);
}
}
// If the first argument is negative zero and the second argument is greater than zero but not a finite odd integer, or
// the first argument is negative infinity and the second argument is less than zero but not a finite odd integer, then the result is positive zero.
for (long i : INTS) {
if (i > 0L && (i & 1L) == 0L) {
- assertEquals(0.0, FastMath.pow(-0.0, i), EXACT);
+ assertEquals(0.0, AccurateMath.pow(-0.0, i), EXACT);
}
}
for (long i : INTS) {
if (i < 0L && (i & 1L) == 0L) {
- assertEquals(0.0, FastMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+ assertEquals(0.0, AccurateMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
}
}
// If the first argument is negative zero and the second argument is a positive finite odd integer, or
// the first argument is negative infinity and the second argument is a negative finite odd integer, then the result is negative zero.
for (long i : INTS) {
if (i > 0L && (i & 1L) == 1L) {
- assertEquals(-0.0, FastMath.pow(-0.0, i), EXACT);
+ assertEquals(-0.0, AccurateMath.pow(-0.0, i), EXACT);
}
}
for (long i : INTS) {
if (i < 0L && (i & 1L) == 1L) {
- assertEquals(-0.0, FastMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+ assertEquals(-0.0, AccurateMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
}
}
// If the first argument is negative zero and the second argument is less than zero but not a finite odd integer, or
// the first argument is negative infinity and the second argument is greater than zero but not a finite odd integer, then the result is positive infinity.
for (long i : INTS) {
if (i > 0L && (i & 1L) == 0L) {
- assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
}
}
for (long i : INTS) {
if (i < 0L && (i & 1L) == 0L) {
- assertEquals(Double.POSITIVE_INFINITY, FastMath.pow(-0.0, i), EXACT);
+ assertEquals(Double.POSITIVE_INFINITY, AccurateMath.pow(-0.0, i), EXACT);
}
}
// If the first argument is negative zero and the second argument is a negative finite odd integer, or
// the first argument is negative infinity and the second argument is a positive finite odd integer, then the result is negative infinity.
for (long i : INTS) {
if (i > 0L && (i & 1L) == 1L) {
- assertEquals(Double.NEGATIVE_INFINITY, FastMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.pow(Double.NEGATIVE_INFINITY, i), EXACT);
}
}
for (long i : INTS) {
if (i < 0L && (i & 1L) == 1L) {
- assertEquals(Double.NEGATIVE_INFINITY, FastMath.pow(-0.0, i), EXACT);
+ assertEquals(Double.NEGATIVE_INFINITY, AccurateMath.pow(-0.0, i), EXACT);
}
}
for (double d : DOUBLES) {
@@ -1515,9 +1515,9 @@ public class FastMathTest {
if (d < 0.0 && Math.abs(d) <= Double.MAX_VALUE) {
for (long i : INTS) {
// if the second argument is a finite even integer, the result is equal to the result of raising the absolute value of the first argument to the power of the second argument
- if ((i & 1L) == 0L) assertEquals(FastMath.pow(-d, i), FastMath.pow(d, i), EXACT);
+ if ((i & 1L) == 0L) assertEquals(AccurateMath.pow(-d, i), AccurateMath.pow(d, i), EXACT);
// if the second argument is a finite odd integer, the result is equal to the negative of the result of raising the absolute value of the first argument to the power of the second argument
- else assertEquals(-FastMath.pow(-d, i), FastMath.pow(d, i), EXACT);
+ else assertEquals(-AccurateMath.pow(-d, i), AccurateMath.pow(d, i), EXACT);
// if the second argument is finite and not an integer, then the result is NaN. <- Impossible with int.
}
}
@@ -1541,13 +1541,13 @@ public class FastMathTest {
if (bdSum.compareTo(BigInteger.valueOf(Integer.MIN_VALUE)) < 0 ||
bdSum.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) > 0) {
try {
- FastMath.incrementExact(a);
+ AccurateMath.incrementExact(a);
Assert.fail("an exception should have been thrown");
} catch (MathArithmeticException mae) {
// expected
}
} else {
- assertEquals(bdSum, BigInteger.valueOf(FastMath.incrementExact(a)));
+ assertEquals(bdSum, BigInteger.valueOf(AccurateMath.incrementExact(a)));
}
}
}
@@ -1567,13 +1567,13 @@ public class FastMathTest {
if (bdSub.compareTo(BigInteger.valueOf(Integer.MIN_VALUE)) < 0 ||
bdSub.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) > 0) {
try {
- FastMath.decrementExact(a);
+ AccurateMath.decrementExact(a);
fail("an exception should have been thrown");
} catch (MathArithmeticException mae) {
// expected
}
} else {
- assertEquals(bdSub, BigInteger.valueOf(FastMath.decrementExact(a)));
+ assertEquals(bdSub, BigInteger.valueOf(AccurateMath.decrementExact(a)));
}
}
}
@@ -1595,13 +1595,13 @@ public class FastMathTest {
if (bdSum.compareTo(BigInteger.valueOf(Integer.MIN_VALUE)) < 0 ||
bdSum.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) > 0) {
try {
- FastMath.addExact(a, b);
+ AccurateMath.addExact(a, b);
fail("an exception should have been thrown");
} catch (MathArithmeticException mae) {
// expected
}
} else {
- assertEquals(bdSum, BigInteger.valueOf(FastMath.addExact(a, b)));
+ assertEquals(bdSum, BigInteger.valueOf(AccurateMath.addExact(a, b)));
}
}
}
@@ -1624,13 +1624,13 @@ public class FastMathTest {
if (bdSum.compareTo(BigInteger.valueOf(Long.MIN_VALUE)) < 0 ||
bdSum.compareTo(BigInteger.valueOf(Long.MAX_VALUE)) > 0) {
try {
- FastMath.addExact(a, b);
+ AccurateMath.addExact(a, b);
fail("an exception should have been thrown");
} catch (MathArithmeticException mae) {
// expected
}
} else {
- assertEquals(bdSum, BigInteger.valueOf(FastMath.addExact(a, b)));
+ assertEquals(bdSum, BigInteger.valueOf(AccurateMath.addExact(a, b)));
}
}
}
@@ -1653,13 +1653,13 @@ public class FastMathTest {
if (bdSub.compareTo(BigInteger.valueOf(Integer.MIN_VALUE)) < 0 ||
bdSub.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) > 0) {
try {
- FastMath.subtractExact(a, b);
+ AccurateMath.subtractExact(a, b);
fail("an exception should have been thrown");
} catch (MathArithmeticException mae) {
// expected
}
} else {
- assertEquals(bdSub, BigInteger.valueOf(FastMath.subtractExact(a, b)));
+ assertEquals(bdSub, BigInteger.valueOf(AccurateMath.subtractExact(a, b)));
}
}
}
@@ -1682,13 +1682,13 @@ public class FastMathTest {
if (bdSub.compareTo(BigInteger.valueOf(Long.MIN_VALUE)) < 0 ||
bdSub.compareTo(BigInteger.valueOf(Long.MAX_VALUE)) > 0) {
try {
- FastMath.subtractExact(a, b);
+ AccurateMath.subtractExact(a, b);
fail("an exception should have been thrown");
} catch (MathArithmeticException mae) {
// expected
}
} else {
- assertEquals(bdSub, BigInteger.valueOf(FastMath.subtractExact(a, b)));
+ assertEquals(bdSub, BigInteger.valueOf(AccurateMath.subtractExact(a, b)));
}
}
}
@@ -1711,13 +1711,13 @@ public class FastMathTest {
if (bdMul.compareTo(BigInteger.valueOf(Integer.MIN_VALUE)) < 0 ||
bdMul.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) > 0) {
try {
- FastMath.multiplyExact(a, b);
+ AccurateMath.multiplyExact(a, b);
fail("an exception should have been thrown " + a + b);
} catch (MathArithmeticException mae) {
// expected
}
} else {
- assertEquals(bdMul, BigInteger.valueOf(FastMath.multiplyExact(a, b)));
+ assertEquals(bdMul, BigInteger.valueOf(AccurateMath.multiplyExact(a, b)));
}
}
}
@@ -1740,13 +1740,13 @@ public class FastMathTest {
if (bdMul.compareTo(BigInteger.valueOf(Long.MIN_VALUE)) < 0 ||
bdMul.compareTo(BigInteger.valueOf(Long.MAX_VALUE)) > 0) {
try {
- FastMath.multiplyExact(a, b);
+ AccurateMath.multiplyExact(a, b);
fail("an exception should have been thrown " + a + b);
} catch (MathArithmeticException mae) {
// expected
}
} else {
- assertEquals(bdMul, BigInteger.valueOf(FastMath.multiplyExact(a, b)));
+ assertEquals(bdMul, BigInteger.valueOf(AccurateMath.multiplyExact(a, b)));
}
}
}
@@ -1754,31 +1754,31 @@ public class FastMathTest {
@Test(expected=MathArithmeticException.class)
public void testToIntExactTooLow() {
- FastMath.toIntExact(-1l + Integer.MIN_VALUE);
+ AccurateMath.toIntExact(-1l + Integer.MIN_VALUE);
}
@Test(expected=MathArithmeticException.class)
public void testToIntExactTooHigh() {
- FastMath.toIntExact(+1l + Integer.MAX_VALUE);
+ AccurateMath.toIntExact(+1l + Integer.MAX_VALUE);
}
@Test
public void testToIntExact() {
for (int n = -1000; n < 1000; ++n) {
- assertEquals(n, FastMath.toIntExact(0l + n));
+ assertEquals(n, AccurateMath.toIntExact(0l + n));
}
- assertEquals(Integer.MIN_VALUE, FastMath.toIntExact(0l + Integer.MIN_VALUE));
- assertEquals(Integer.MAX_VALUE, FastMath.toIntExact(0l + Integer.MAX_VALUE));
+ assertEquals(Integer.MIN_VALUE, AccurateMath.toIntExact(0l + Integer.MIN_VALUE));
+ assertEquals(Integer.MAX_VALUE, AccurateMath.toIntExact(0l + Integer.MAX_VALUE));
}
@Test
public void testFloorDivInt() {
- assertEquals(+1, FastMath.floorDiv(+4, +3));
- assertEquals(-2, FastMath.floorDiv(-4, +3));
- assertEquals(-2, FastMath.floorDiv(+4, -3));
- assertEquals(+1, FastMath.floorDiv(-4, -3));
+ assertEquals(+1, AccurateMath.floorDiv(+4, +3));
+ assertEquals(-2, AccurateMath.floorDiv(-4, +3));
+ assertEquals(-2, AccurateMath.floorDiv(+4, -3));
+ assertEquals(+1, AccurateMath.floorDiv(-4, -3));
try {
- FastMath.floorDiv(1, 0);
+ AccurateMath.floorDiv(1, 0);
fail("an exception should have been thrown");
} catch (MathArithmeticException mae) {
// expected
@@ -1786,7 +1786,7 @@ public class FastMathTest {
for (int a = -100; a <= 100; ++a) {
for (int b = -100; b <= 100; ++b) {
if (b != 0) {
- assertEquals(poorManFloorDiv(a, b), FastMath.floorDiv(a, b));
+ assertEquals(poorManFloorDiv(a, b), AccurateMath.floorDiv(a, b));
}
}
}
@@ -1794,12 +1794,12 @@ public class FastMathTest {
@Test
public void testFloorModInt() {
- assertEquals(+1, FastMath.floorMod(+4, +3));
- assertEquals(+2, FastMath.floorMod(-4, +3));
- assertEquals(-2, FastMath.floorMod(+4, -3));
- assertEquals(-1, FastMath.floorMod(-4, -3));
+ assertEquals(+1, AccurateMath.floorMod(+4, +3));
+ assertEquals(+2, AccurateMath.floorMod(-4, +3));
+ assertEquals(-2, AccurateMath.floorMod(+4, -3));
+ assertEquals(-1, AccurateMath.floorMod(-4, -3));
try {
- FastMath.floorMod(1, 0);
+ AccurateMath.floorMod(1, 0);
fail("an exception should have been thrown");
} catch (MathArithmeticException mae) {
// expected
@@ -1807,7 +1807,7 @@ public class FastMathTest {
for (int a = -100; a <= 100; ++a) {
for (int b = -100; b <= 100; ++b) {
if (b != 0) {
- assertEquals(poorManFloorMod(a, b), FastMath.floorMod(a, b));
+ assertEquals(poorManFloorMod(a, b), AccurateMath.floorMod(a, b));
}
}
}
@@ -1822,16 +1822,16 @@ public class FastMathTest {
int b = generator.nextInt();
if (b == 0) {
try {
- FastMath.floorDiv(a, b);
+ AccurateMath.floorDiv(a, b);
fail("an exception should have been thrown");
} catch (MathArithmeticException mae) {
// expected
}
} else {
- int d = FastMath.floorDiv(a, b);
- int m = FastMath.floorMod(a, b);
- assertEquals(FastMath.toIntExact(poorManFloorDiv(a, b)), d);
- assertEquals(FastMath.toIntExact(poorManFloorMod(a, b)), m);
+ int d = AccurateMath.floorDiv(a, b);
+ int m = AccurateMath.floorMod(a, b);
+ assertEquals(AccurateMath.toIntExact(poorManFloorDiv(a, b)), d);
+ assertEquals(AccurateMath.toIntExact(poorManFloorMod(a, b)), m);
assertEquals(a, d * b + m);
if (b < 0) {
assertTrue(m <= 0);
@@ -1846,12 +1846,12 @@ public class FastMathTest {
@Test
public void testFloorDivLong() {
- assertEquals(+1l, FastMath.floorDiv(+4l, +3l));
- assertEquals(-2l, FastMath.floorDiv(-4l, +3l));
- assertEquals(-2l, FastMath.floorDiv(+4l, -3l));
- assertEquals(+1l, FastMath.floorDiv(-4l, -3l));
+ assertEquals(+1l, AccurateMath.floorDiv(+4l, +3l));
+ assertEquals(-2l, AccurateMath.floorDiv(-4l, +3l));
+ assertEquals(-2l, AccurateMath.floorDiv(+4l, -3l));
+ assertEquals(+1l, AccurateMath.floorDiv(-4l, -3l));
try {
- FastMath.floorDiv(1l, 0l);
+ AccurateMath.floorDiv(1l, 0l);
fail("an exception should have been thrown");
} catch (MathArithmeticException mae) {
// expected
@@ -1859,7 +1859,7 @@ public class FastMathTest {
for (long a = -100l; a <= 100l; ++a) {
for (long b = -100l; b <= 100l; ++b) {
if (b != 0) {
- assertEquals(poorManFloorDiv(a, b), FastMath.floorDiv(a, b));
+ assertEquals(poorManFloorDiv(a, b), AccurateMath.floorDiv(a, b));
}
}
}
@@ -1867,12 +1867,12 @@ public class FastMathTest {
@Test
public void testFloorModLong() {
- assertEquals(+1l, FastMath.floorMod(+4l, +3l));
- assertEquals(+2l, FastMath.floorMod(-4l, +3l));
- assertEquals(-2l, FastMath.floorMod(+4l, -3l));
- assertEquals(-1l, FastMath.floorMod(-4l, -3l));
+ assertEquals(+1l, AccurateMath.floorMod(+4l, +3l));
+ assertEquals(+2l, AccurateMath.floorMod(-4l, +3l));
+ assertEquals(-2l, AccurateMath.floorMod(+4l, -3l));
+ assertEquals(-1l, AccurateMath.floorMod(-4l, -3l));
try {
- FastMath.floorMod(1l, 0l);
+ AccurateMath.floorMod(1l, 0l);
fail("an exception should have been thrown");
} catch (MathArithmeticException mae) {
// expected
@@ -1880,7 +1880,7 @@ public class FastMathTest {
for (long a = -100l; a <= 100l; ++a) {
for (long b = -100l; b <= 100l; ++b) {
if (b != 0) {
- assertEquals(poorManFloorMod(a, b), FastMath.floorMod(a, b));
+ assertEquals(poorManFloorMod(a, b), AccurateMath.floorMod(a, b));
}
}
}
@@ -1895,14 +1895,14 @@ public class FastMathTest {
long b = generator.nextLong();
if (b == 0) {
try {
- FastMath.floorDiv(a, b);
+ AccurateMath.floorDiv(a, b);
fail("an exception should have been thrown");
} catch (MathArithmeticException mae) {
// expected
}
} else {
- long d = FastMath.floorDiv(a, b);
- long m = FastMath.floorMod(a, b);
+ long d = AccurateMath.floorDiv(a, b);
+ long m = AccurateMath.floorMod(a, b);
assertEquals(poorManFloorDiv(a, b), d);
assertEquals(poorManFloorMod(a, b), m);
assertEquals(a, d * b + m);
@@ -1953,12 +1953,12 @@ public class FastMathTest {
public void testRoundDown() {
double x = 0x1.fffffffffffffp-2; // greatest floating point value less than 0.5
assertTrue(x < 0.5d);
- assertEquals(0, FastMath.round(x));
+ assertEquals(0, AccurateMath.round(x));
x = 4503599627370497.0; // x = Math.pow(2, 52) + 1;
assertEquals("4503599627370497", new BigDecimal(x).toString());
assertTrue(x == Math.rint(x));
- assertTrue(x == FastMath.round(x));
+ assertTrue(x == AccurateMath.round(x));
//assertTrue(x == Math.round(x)); // fails with Java 7, fixed in Java 8
}
diff --git a/commons-math-legacy/pom.xml b/commons-math-legacy/pom.xml
index 56876b380..33504221b 100644
--- a/commons-math-legacy/pom.xml
+++ b/commons-math-legacy/pom.xml
@@ -116,12 +116,12 @@
ex-1 function.
@@ -30,7 +30,7 @@ public class Expm1 implements UnivariateDifferentiableFunction {
/** {@inheritDoc} */
@Override
public double value(double x) {
- return FastMath.expm1(x);
+ return AccurateMath.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 9f8f99643..26267cead 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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* {@code floor} function.
@@ -29,6 +29,6 @@ public class Floor implements UnivariateFunction {
/** {@inheritDoc} */
@Override
public double value(double x) {
- return FastMath.floor(x);
+ return AccurateMath.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 0c6d46f8a..b5c6af4e4 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.analysis.differentiation.UnivariateDiffer
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
import org.apache.commons.numbers.core.Precision;
/**
@@ -76,7 +76,7 @@ public class Gaussian implements UnivariateDifferentiableFunction {
public Gaussian(double mean,
double sigma)
throws NotStrictlyPositiveException {
- this(1 / (sigma * FastMath.sqrt(2 * Math.PI)), mean, sigma);
+ this(1 / (sigma * AccurateMath.sqrt(2 * Math.PI)), mean, sigma);
}
/**
@@ -194,7 +194,7 @@ public class Gaussian implements UnivariateDifferentiableFunction {
private static double value(double xMinusMean,
double norm,
double i2s2) {
- return norm * FastMath.exp(-xMinusMean * xMinusMean * i2s2);
+ return norm * AccurateMath.exp(-xMinusMean * xMinusMean * i2s2);
}
/** {@inheritDoc}
@@ -217,7 +217,7 @@ public class Gaussian implements UnivariateDifferentiableFunction {
final double[] p = new double[f.length];
p[0] = 1;
final double u2 = u * u;
- double coeff = norm * FastMath.exp(-0.5 * u2);
+ double coeff = norm * AccurateMath.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 b8fac67b5..4c8a29e42 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.DerivativeStruct
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
*
@@ -112,7 +112,7 @@ public class HarmonicOscillator implements UnivariateDifferentiableFunction {
final double xTimesOmegaPlusPhase = omega * x + phase;
final double a = HarmonicOscillator.value(xTimesOmegaPlusPhase, 1);
- final double p = -amplitude * FastMath.sin(xTimesOmegaPlusPhase);
+ final double p = -amplitude * AccurateMath.sin(xTimesOmegaPlusPhase);
final double w = p * x;
return new double[] { a, w, p };
@@ -147,7 +147,7 @@ public class HarmonicOscillator implements UnivariateDifferentiableFunction {
*/
private static double value(double xTimesOmegaPlusPhase,
double amplitude) {
- return amplitude * FastMath.cos(xTimesOmegaPlusPhase);
+ return amplitude * AccurateMath.cos(xTimesOmegaPlusPhase);
}
/** {@inheritDoc}
@@ -160,9 +160,9 @@ public class HarmonicOscillator implements UnivariateDifferentiableFunction {
double[] f = new double[t.getOrder() + 1];
final double alpha = omega * x + phase;
- f[0] = amplitude * FastMath.cos(alpha);
+ f[0] = amplitude * AccurateMath.cos(alpha);
if (f.length > 1) {
- f[1] = -amplitude * omega * FastMath.sin(alpha);
+ f[1] = -amplitude * omega * AccurateMath.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 0db005b19..6dfdb21f1 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 @@ package org.apache.commons.math4.legacy.analysis.function;
import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Natural logarithm function.
@@ -30,7 +30,7 @@ public class Log implements UnivariateDifferentiableFunction {
/** {@inheritDoc} */
@Override
public double value(double x) {
- return FastMath.log(x);
+ return AccurateMath.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 c0b36ae12..e7228a365 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 @@ package org.apache.commons.math4.legacy.analysis.function;
import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Base 10 logarithm function.
@@ -31,7 +31,7 @@ public class Log10 implements UnivariateDifferentiableFunction {
/** {@inheritDoc} */
@Override
public double value(double x) {
- return FastMath.log10(x);
+ return AccurateMath.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 d6f0b146c..1f244046e 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 @@ package org.apache.commons.math4.legacy.analysis.function;
import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* log(1 + p) function.
@@ -30,7 +30,7 @@ public class Log1p implements UnivariateDifferentiableFunction {
/** {@inheritDoc} */
@Override
public double value(double x) {
- return FastMath.log1p(x);
+ return AccurateMath.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 e5bfe7b7e..18c27702d 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.analysis.differentiation.UnivariateDiffer
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
*
@@ -147,10 +147,10 @@ public class Logistic implements UnivariateDifferentiableFunction {
final double mMinusX = param[1] - x;
final double oneOverN = 1 / param[5];
- final double exp = FastMath.exp(b * mMinusX);
+ final double exp = AccurateMath.exp(b * mMinusX);
final double qExp = q * exp;
final double qExp1 = qExp + 1;
- final double factor1 = (param[0] - param[4]) * oneOverN / FastMath.pow(qExp1, oneOverN);
+ final double factor1 = (param[0] - param[4]) * oneOverN / AccurateMath.pow(qExp1, oneOverN);
final double factor2 = -factor1 / qExp1;
// Components of the gradient.
@@ -159,7 +159,7 @@ public class Logistic implements UnivariateDifferentiableFunction {
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 * FastMath.log(qExp1) * oneOverN;
+ final double gn = factor1 * AccurateMath.log(qExp1) * oneOverN;
return new double[] { gk, gm, gb, gq, ga, gn };
}
@@ -207,7 +207,7 @@ public class Logistic implements UnivariateDifferentiableFunction {
double q,
double a,
double oneOverN) {
- return a + (k - a) / FastMath.pow(1 + q * FastMath.exp(b * mMinusX), oneOverN);
+ return a + (k - a) / AccurateMath.pow(1 + q * AccurateMath.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 2d0c7203c..c04baf665 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.analysis.differentiation.UnivariateDiffer
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
*
@@ -153,7 +153,7 @@ public class Logit implements UnivariateDifferentiableFunction {
if (x < lo || x > hi) {
throw new OutOfRangeException(x, lo, hi);
}
- return FastMath.log((x - lo) / (hi - x));
+ return AccurateMath.log((x - lo) / (hi - x));
}
/** {@inheritDoc}
@@ -170,7 +170,7 @@ public class Logit implements UnivariateDifferentiableFunction {
double[] f = new double[t.getOrder() + 1];
// function value
- f[0] = FastMath.log((x - lo) / (hi - x));
+ f[0] = AccurateMath.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 023fd25ad..f338b8138 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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Maximum function.
@@ -29,6 +29,6 @@ public class Max implements BivariateFunction {
/** {@inheritDoc} */
@Override
public double value(double x, double y) {
- return FastMath.max(x, y);
+ return AccurateMath.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 b9d49608b..90eba84a6 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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Minimum function.
@@ -29,6 +29,6 @@ public class Min implements BivariateFunction {
/** {@inheritDoc} */
@Override
public double value(double x, double y) {
- return FastMath.min(x, y);
+ return AccurateMath.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 1452c80ec..70b691544 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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Power function.
@@ -29,6 +29,6 @@ public class Pow implements BivariateFunction {
/** {@inheritDoc} */
@Override
public double value(double x, double y) {
- return FastMath.pow(x, y);
+ return AccurateMath.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 584b801a4..91cfc58ad 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 @@ package org.apache.commons.math4.legacy.analysis.function;
import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Power function.
@@ -40,7 +40,7 @@ public class Power implements UnivariateDifferentiableFunction {
/** {@inheritDoc} */
@Override
public double value(double x) {
- return FastMath.pow(x, p);
+ return AccurateMath.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 90c812c85..7b81161a9 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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* {@code rint} function.
@@ -29,6 +29,6 @@ public class Rint implements UnivariateFunction {
/** {@inheritDoc} */
@Override
public double value(double x) {
- return FastMath.rint(x);
+ return AccurateMath.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 1f298c456..811fb8a4e 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.DerivativeStruct
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
*
@@ -114,7 +114,7 @@ public class Sigmoid implements UnivariateDifferentiableFunction {
DimensionMismatchException {
validateParameters(param);
- final double invExp1 = 1 / (1 + FastMath.exp(-x));
+ final double invExp1 = 1 / (1 + AccurateMath.exp(-x));
return new double[] { 1 - invExp1, invExp1 };
}
@@ -150,7 +150,7 @@ public class Sigmoid implements UnivariateDifferentiableFunction {
private static double value(double x,
double lo,
double hi) {
- return lo + (hi - lo) / (1 + FastMath.exp(-x));
+ return lo + (hi - lo) / (1 + AccurateMath.exp(-x));
}
/** {@inheritDoc}
@@ -161,7 +161,7 @@ public class Sigmoid implements UnivariateDifferentiableFunction {
throws DimensionMismatchException {
double[] f = new double[t.getOrder() + 1];
- final double exp = FastMath.exp(-t.getValue());
+ final double exp = AccurateMath.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 858a48b7d..067eac336 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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* {@code signum} function.
@@ -29,6 +29,6 @@ public class Signum implements UnivariateFunction {
/** {@inheritDoc} */
@Override
public double value(double x) {
- return FastMath.signum(x);
+ return AccurateMath.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 ee722853f..81aaedde4 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 @@ package org.apache.commons.math4.legacy.analysis.function;
import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Sine function.
@@ -30,7 +30,7 @@ public class Sin implements UnivariateDifferentiableFunction {
/** {@inheritDoc} */
@Override
public double value(double x) {
- return FastMath.sin(x);
+ return AccurateMath.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 f23c542cc..a33e0da5d 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 @@ package org.apache.commons.math4.legacy.analysis.function;
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Sinc function,
@@ -81,14 +81,14 @@ public class Sinc implements UnivariateDifferentiableFunction {
/** {@inheritDoc} */
@Override
public double value(final double x) {
- final double scaledX = normalized ? FastMath.PI * x : x;
- if (FastMath.abs(scaledX) <= SHORTCUT) {
+ final double scaledX = normalized ? AccurateMath.PI * x : x;
+ if (AccurateMath.abs(scaledX) <= SHORTCUT) {
// use Taylor series
final double scaledX2 = scaledX * scaledX;
return ((scaledX2 - 20) * scaledX2 + 120) / 120;
} else {
// use definition expression
- return FastMath.sin(scaledX) / scaledX;
+ return AccurateMath.sin(scaledX) / scaledX;
}
}
@@ -99,12 +99,12 @@ public class Sinc implements UnivariateDifferentiableFunction {
public DerivativeStructure value(final DerivativeStructure t)
throws DimensionMismatchException {
- final double scaledX = (normalized ? FastMath.PI : 1) * t.getValue();
+ final double scaledX = (normalized ? AccurateMath.PI : 1) * t.getValue();
final double scaledX2 = scaledX * scaledX;
double[] f = new double[t.getOrder() + 1];
- if (FastMath.abs(scaledX) <= SHORTCUT) {
+ if (AccurateMath.abs(scaledX) <= SHORTCUT) {
for (int i = 0; i < f.length; ++i) {
final int k = i / 2;
@@ -122,8 +122,8 @@ public class Sinc implements UnivariateDifferentiableFunction {
} else {
final double inv = 1 / scaledX;
- final double cos = FastMath.cos(scaledX);
- final double sin = FastMath.sin(scaledX);
+ final double cos = AccurateMath.cos(scaledX);
+ final double sin = AccurateMath.sin(scaledX);
f[0] = inv * sin;
@@ -182,10 +182,10 @@ public class Sinc implements UnivariateDifferentiableFunction {
}
if (normalized) {
- double scale = FastMath.PI;
+ double scale = AccurateMath.PI;
for (int i = 1; i < f.length; ++i) {
f[i] *= scale;
- scale *= FastMath.PI;
+ scale *= AccurateMath.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 98e11d92c..4a9a51580 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 @@ package org.apache.commons.math4.legacy.analysis.function;
import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Hyperbolic sine function.
@@ -30,7 +30,7 @@ public class Sinh implements UnivariateDifferentiableFunction {
/** {@inheritDoc} */
@Override
public double value(double x) {
- return FastMath.sinh(x);
+ return AccurateMath.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 3a3da21d7..f8146aa4f 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 @@ package org.apache.commons.math4.legacy.analysis.function;
import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Square-root function.
@@ -30,7 +30,7 @@ public class Sqrt implements UnivariateDifferentiableFunction {
/** {@inheritDoc} */
@Override
public double value(double x) {
- return FastMath.sqrt(x);
+ return AccurateMath.sqrt(x);
}
/** {@inheritDoc}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/StepFunction.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/StepFunction.java
index edb5e642d..d4fb09f6b 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/StepFunction.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/function/StepFunction.java
@@ -24,7 +24,7 @@ import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
import org.apache.commons.math4.legacy.exception.NoDataException;
import org.apache.commons.math4.legacy.exception.NonMonotonicSequenceException;
import org.apache.commons.math4.legacy.exception.NullArgumentException;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
*
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 b79bbbe35..5fa6f4f45 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 @@ package org.apache.commons.math4.legacy.analysis.function;
import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Tangent function.
@@ -30,7 +30,7 @@ public class Tan implements UnivariateDifferentiableFunction {
/** {@inheritDoc} */
@Override
public double value(double x) {
- return FastMath.tan(x);
+ return AccurateMath.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 697262632..26f801607 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 @@ package org.apache.commons.math4.legacy.analysis.function;
import org.apache.commons.math4.legacy.analysis.differentiation.DerivativeStructure;
import org.apache.commons.math4.legacy.analysis.differentiation.UnivariateDifferentiableFunction;
-import org.apache.commons.math4.legacy.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Hyperbolic tangent function.
@@ -30,7 +30,7 @@ public class Tanh implements UnivariateDifferentiableFunction {
/** {@inheritDoc} */
@Override
public double value(double x) {
- return FastMath.tanh(x);
+ return AccurateMath.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 5a193c902..840024049 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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* {@code ulp} function.
@@ -29,6 +29,6 @@ public class Ulp implements UnivariateFunction {
/** {@inheritDoc} */
@Override
public double value(double x) {
- return FastMath.ulp(x);
+ return AccurateMath.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 e768c6e74..e9011bc66 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.analysis.integration.gauss.GaussIntegrato
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* This algorithm divides the integration interval into equally-sized
@@ -122,10 +122,10 @@ public class IterativeLegendreGaussIntegrator
final double t = stage(n);
// Estimate the error.
- final double delta = FastMath.abs(t - oldt);
+ final double delta = AccurateMath.abs(t - oldt);
final double limit =
- FastMath.max(getAbsoluteAccuracy(),
- getRelativeAccuracy() * (FastMath.abs(oldt) + FastMath.abs(t)) * 0.5);
+ AccurateMath.max(getAbsoluteAccuracy(),
+ getRelativeAccuracy() * (AccurateMath.abs(oldt) + AccurateMath.abs(t)) * 0.5);
// check convergence
if (iterations.getCount() + 1 >= getMinimalIterationCount() &&
@@ -134,8 +134,8 @@ public class IterativeLegendreGaussIntegrator
}
// Prepare next iteration.
- final double ratio = FastMath.min(4, FastMath.pow(delta / limit, 0.5 / numberOfPoints));
- n = FastMath.max((int) (ratio * n), n + 1);
+ final double ratio = AccurateMath.min(4, AccurateMath.pow(delta / limit, 0.5 / numberOfPoints));
+ n = AccurateMath.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 e748425f2..30668512c 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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Implements the
@@ -113,7 +113,7 @@ public class MidPointIntegrator extends BaseAbstractUnivariateIntegrator {
double diffMaxMin) {
// number of points in the previous stage. This stage will contribute
// 2*3^{n-1} more points.
- final long np = (long) FastMath.pow(3, n - 1);
+ final long np = (long) AccurateMath.pow(3, n - 1);
double sum = 0;
// spacing between adjacent new points
@@ -151,9 +151,9 @@ public class MidPointIntegrator extends BaseAbstractUnivariateIntegrator {
final int i = iterations.getCount();
final double t = stage(i, oldt, min, diff);
if (i >= getMinimalIterationCount()) {
- final double delta = FastMath.abs(t - oldt);
+ final double delta = AccurateMath.abs(t - oldt);
final double rLimit =
- getRelativeAccuracy() * (FastMath.abs(oldt) + FastMath.abs(t)) * 0.5;
+ getRelativeAccuracy() * (AccurateMath.abs(oldt) + AccurateMath.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 c2c6aa62b..771a7b803 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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Implements the
@@ -120,8 +120,8 @@ public class RombergIntegrator extends BaseAbstractUnivariateIntegrator {
}
final double s = currentRow[i];
if (i >= getMinimalIterationCount()) {
- final double delta = FastMath.abs(s - olds);
- final double rLimit = getRelativeAccuracy() * (FastMath.abs(olds) + FastMath.abs(s)) * 0.5;
+ final double delta = AccurateMath.abs(s - olds);
+ final double rLimit = getRelativeAccuracy() * (AccurateMath.abs(olds) + AccurateMath.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 caf36d757..26630aa21 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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Implements
@@ -106,8 +106,8 @@ public class SimpsonIntegrator extends BaseAbstractUnivariateIntegrator {
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 = FastMath.abs(s - olds);
- final double rLimit = getRelativeAccuracy() * (FastMath.abs(olds) + FastMath.abs(s)) * 0.5;
+ final double delta = AccurateMath.abs(s - olds);
+ final double rLimit = getRelativeAccuracy() * (AccurateMath.abs(olds) + AccurateMath.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 7f7fa6e53..ed1176fa5 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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Implements the
@@ -139,9 +139,9 @@ public class TrapezoidIntegrator extends BaseAbstractUnivariateIntegrator {
final int i = iterations.getCount();
final double t = stage(this, i);
if (i >= getMinimalIterationCount()) {
- final double delta = FastMath.abs(t - oldt);
+ final double delta = AccurateMath.abs(t - oldt);
final double rLimit =
- getRelativeAccuracy() * (FastMath.abs(oldt) + FastMath.abs(t)) * 0.5;
+ getRelativeAccuracy() * (AccurateMath.abs(oldt) + AccurateMath.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/GaussIntegrator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/gauss/GaussIntegrator.java
index 967ca875f..616b48b47 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/gauss/GaussIntegrator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/integration/gauss/GaussIntegrator.java
@@ -18,7 +18,7 @@ package org.apache.commons.math4.legacy.analysis.integration.gauss;
import org.apache.commons.math4.legacy.analysis.UnivariateFunction;
import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
import org.apache.commons.math4.legacy.util.Pair;
/**
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 76cd4caf5..edc5a9438 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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
import org.apache.commons.math4.legacy.util.Pair;
/**
@@ -74,8 +74,8 @@ public class HermiteRuleFactory extends BaseRuleFactory(1 - |x|3)3 for |x| < 1, 0 otherwise.
*/
private static double tricube(final double x) {
- final double absX = FastMath.abs(x);
+ final double absX = AccurateMath.abs(x);
if (absX >= 1.0) {
return 0.0;
}
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunction.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunction.java
index 26d040dfd..31e0c5268 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunction.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunction.java
@@ -26,7 +26,7 @@ import org.apache.commons.math4.legacy.exception.NoDataException;
import org.apache.commons.math4.legacy.exception.NonMonotonicSequenceException;
import org.apache.commons.math4.legacy.exception.NullArgumentException;
import org.apache.commons.math4.legacy.exception.OutOfRangeException;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Function that implements the
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolator.java
index 09797ccbf..09f91a36c 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/PiecewiseBicubicSplineInterpolator.java
@@ -20,7 +20,7 @@ import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
import org.apache.commons.math4.legacy.exception.NoDataException;
import org.apache.commons.math4.legacy.exception.NonMonotonicSequenceException;
import org.apache.commons.math4.legacy.exception.NullArgumentException;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Generates a piecewise-bicubic interpolating function.
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/SplineInterpolator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/SplineInterpolator.java
index 499921937..be313dd61 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/SplineInterpolator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/SplineInterpolator.java
@@ -22,7 +22,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.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Computes a natural (also known as "free", "unclamped") cubic spline interpolation for the data set.
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolatingFunction.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolatingFunction.java
index 94f0a46d3..0977eb89b 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolatingFunction.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolatingFunction.java
@@ -21,7 +21,7 @@ import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
import org.apache.commons.math4.legacy.exception.NoDataException;
import org.apache.commons.math4.legacy.exception.NonMonotonicSequenceException;
import org.apache.commons.math4.legacy.exception.OutOfRangeException;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Function that implements the
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolator.java
index 2159c4bad..0ff84ebbd 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/TricubicInterpolator.java
@@ -20,7 +20,7 @@ import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
import org.apache.commons.math4.legacy.exception.NoDataException;
import org.apache.commons.math4.legacy.exception.NonMonotonicSequenceException;
import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Generates a tricubic interpolating function.
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/UnivariatePeriodicInterpolator.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/UnivariatePeriodicInterpolator.java
index 3b6bdec67..ee1618a24 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/UnivariatePeriodicInterpolator.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/interpolation/UnivariatePeriodicInterpolator.java
@@ -22,7 +22,7 @@ import org.apache.commons.math4.legacy.analysis.UnivariateFunction;
import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
import org.apache.commons.math4.legacy.exception.NonMonotonicSequenceException;
import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Adapter for classes implementing the {@link UnivariateInterpolator}
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 9d8068f84..29f7dc6c1 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.analysis.differentiation.UnivariateDiffer
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Immutable representation of a real polynomial function with real coefficients.
@@ -167,8 +167,8 @@ public class PolynomialFunction implements UnivariateDifferentiableFunction, Ser
*/
public PolynomialFunction add(final PolynomialFunction p) {
// identify the lowest degree polynomial
- final int lowLength = FastMath.min(coefficients.length, p.coefficients.length);
- final int highLength = FastMath.max(coefficients.length, p.coefficients.length);
+ final int lowLength = AccurateMath.min(coefficients.length, p.coefficients.length);
+ final int highLength = AccurateMath.max(coefficients.length, p.coefficients.length);
// build the coefficients array
double[] newCoefficients = new double[highLength];
@@ -192,8 +192,8 @@ public class PolynomialFunction implements UnivariateDifferentiableFunction, Ser
*/
public PolynomialFunction subtract(final PolynomialFunction p) {
// identify the lowest degree polynomial
- int lowLength = FastMath.min(coefficients.length, p.coefficients.length);
- int highLength = FastMath.max(coefficients.length, p.coefficients.length);
+ int lowLength = AccurateMath.min(coefficients.length, p.coefficients.length);
+ int highLength = AccurateMath.max(coefficients.length, p.coefficients.length);
// build the coefficients array
double[] newCoefficients = new double[highLength];
@@ -236,8 +236,8 @@ public class PolynomialFunction implements UnivariateDifferentiableFunction, Ser
for (int i = 0; i < newCoefficients.length; ++i) {
newCoefficients[i] = 0.0;
- for (int j = FastMath.max(0, i + 1 - p.coefficients.length);
- j < FastMath.min(coefficients.length, i + 1);
+ for (int j = AccurateMath.max(0, i + 1 - p.coefficients.length);
+ j < AccurateMath.min(coefficients.length, i + 1);
++j) {
newCoefficients[i] += coefficients[j] * p.coefficients[i-j];
}
@@ -320,7 +320,7 @@ public class PolynomialFunction implements UnivariateDifferentiableFunction, Ser
}
}
- double absAi = FastMath.abs(coefficients[i]);
+ double absAi = AccurateMath.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 55f70c031..e376e2f3f 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
@@ -21,8 +21,8 @@ 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.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.util.FastMath;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Implements the representation of a real polynomial function in
@@ -215,7 +215,7 @@ public class PolynomialFunctionLagrangeForm implements UnivariateFunction {
c[i] = y[i];
d[i] = y[i];
// find out the abscissa closest to z
- final double dist = FastMath.abs(z - x[i]);
+ final double dist = AccurateMath.abs(z - x[i]);
if (dist < min_dist) {
nearest = i;
min_dist = dist;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialSplineFunction.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialSplineFunction.java
index 89f576da6..e232c97b0 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialSplineFunction.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/polynomials/PolynomialSplineFunction.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.exception.util.LocalizedFormats;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
/**
* Represents a polynomial spline function.
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 2a1958a49..6497c739d 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 java.util.Map;
import org.apache.commons.numbers.fraction.BigFraction;
import org.apache.commons.numbers.combinatorics.BinomialCoefficient;
-import org.apache.commons.math4.legacy.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* A collection of static methods that operate on or return polynomials.
@@ -341,7 +341,7 @@ public class PolynomialsUtils {
// First polynomial coefficient.
for (int i = 0; i < dp1; i++){
- newCoefficients[0] += coefficients[i] * FastMath.pow(shift, i);
+ newCoefficients[0] += coefficients[i] * AccurateMath.pow(shift, i);
}
// Superior order.
@@ -349,7 +349,7 @@ public class PolynomialsUtils {
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] * FastMath.pow(shift, j - i);
+ coefficients[j + 1] * AccurateMath.pow(shift, j - i);
}
}
@@ -368,7 +368,7 @@ public class PolynomialsUtils {
final RecurrenceCoefficientsGenerator generator) {
synchronized (coefficients) {
- final int maxDegree = (int) FastMath.floor(FastMath.sqrt(2 * coefficients.size())) - 1;
+ final int maxDegree = (int) AccurateMath.floor(AccurateMath.sqrt(2 * 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 a9e81f32b..8f952e144 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 @@ package org.apache.commons.math4.legacy.analysis.solvers;
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Base class for all bracketing Secant-based methods for root-finding
@@ -210,7 +210,7 @@ public abstract class BaseSecantSolver
// 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 (FastMath.abs(f1) <= ftol) {
+ if (AccurateMath.abs(f1) <= ftol) {
switch (allowed) {
case ANY_SIDE:
return x1;
@@ -241,7 +241,7 @@ public abstract class BaseSecantSolver
// If the current interval is within the given accuracies, we
// are satisfied with the current approximation.
- if (FastMath.abs(x1 - x0) < FastMath.max(rtol * FastMath.abs(x1),
+ if (AccurateMath.abs(x1 - x0) < AccurateMath.max(rtol * AccurateMath.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 8799e4f8b..ff0290c71 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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Implements the
@@ -82,7 +82,7 @@ public class BisectionSolver extends AbstractUnivariateSolver {
max = m;
}
- if (FastMath.abs(max - min) <= absoluteAccuracy) {
+ if (AccurateMath.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/BracketedRealFieldUnivariateSolver.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/BracketedRealFieldUnivariateSolver.java
index 4e3cdd9e2..623dee7e0 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/BracketedRealFieldUnivariateSolver.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/BracketedRealFieldUnivariateSolver.java
@@ -17,7 +17,7 @@
package org.apache.commons.math4.legacy.analysis.solvers;
-import org.apache.commons.math4.legacy.RealFieldElement;
+import org.apache.commons.math4.legacy.core.RealFieldElement;
import org.apache.commons.math4.legacy.analysis.RealFieldUnivariateFunction;
/** Interface for {@link UnivariateSolver (univariate real) root-finding
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 cb54e982f..3bad26297 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.NoBracketingException;
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
import org.apache.commons.numbers.core.Precision;
/**
@@ -199,11 +199,11 @@ public class BracketingNthOrderBrentSolver
// current tightest bracketing of the root
double xA = x[signChangeIndex - 1];
double yA = y[signChangeIndex - 1];
- double absYA = FastMath.abs(yA);
+ double absYA = AccurateMath.abs(yA);
int agingA = 0;
double xB = x[signChangeIndex];
double yB = y[signChangeIndex];
- double absYB = FastMath.abs(yB);
+ double absYB = AccurateMath.abs(yB);
int agingB = 0;
// search loop
@@ -211,8 +211,8 @@ public class BracketingNthOrderBrentSolver
// check convergence of bracketing interval
final double xTol = getAbsoluteAccuracy() +
- getRelativeAccuracy() * FastMath.max(FastMath.abs(xA), FastMath.abs(xB));
- if (((xB - xA) <= xTol) || (FastMath.max(absYA, absYB) < getFunctionValueAccuracy())) {
+ getRelativeAccuracy() * AccurateMath.max(AccurateMath.abs(xA), AccurateMath.abs(xB));
+ if (((xB - xA) <= xTol) || (AccurateMath.max(absYA, absYB) < getFunctionValueAccuracy())) {
switch (allowed) {
case ANY_SIDE :
return absYA < absYB ? xA : xB;
@@ -332,14 +332,14 @@ public class BracketingNthOrderBrentSolver
// the sign change occurs before the inserted point
xB = nextX;
yB = nextY;
- absYB = FastMath.abs(yB);
+ absYB = AccurateMath.abs(yB);
++agingA;
agingB = 0;
} else {
// the sign change occurs after the inserted point
xA = nextX;
yA = nextY;
- absYA = FastMath.abs(yA);
+ absYA = AccurateMath.abs(yA);
agingA = 0;
++agingB;
diff --git a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/FieldBracketingNthOrderBrentSolver.java b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/FieldBracketingNthOrderBrentSolver.java
index 9d5de5e63..05d0ef017 100644
--- a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/FieldBracketingNthOrderBrentSolver.java
+++ b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/solvers/FieldBracketingNthOrderBrentSolver.java
@@ -17,15 +17,15 @@
package org.apache.commons.math4.legacy.analysis.solvers;
-import org.apache.commons.math4.legacy.Field;
-import org.apache.commons.math4.legacy.RealFieldElement;
+import org.apache.commons.math4.legacy.core.Field;
+import org.apache.commons.math4.legacy.core.RealFieldElement;
import org.apache.commons.math4.legacy.analysis.RealFieldUnivariateFunction;
import org.apache.commons.math4.legacy.exception.MathInternalError;
import org.apache.commons.math4.legacy.exception.NoBracketingException;
import org.apache.commons.math4.legacy.exception.NullArgumentException;
import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
import org.apache.commons.math4.legacy.util.IntegerSequence;
-import org.apache.commons.math4.legacy.util.MathArrays;
+import org.apache.commons.math4.legacy.core.MathArrays;
import org.apache.commons.numbers.core.Precision;
/**
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 4de3ca1fe..0f8b4adb7 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
@@ -25,7 +25,7 @@ import org.apache.commons.math4.legacy.exception.NullArgumentException;
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Implements the
@@ -101,13 +101,13 @@ public class LaguerreSolver extends AbstractPolynomialSolver {
// Return the initial guess if it is good enough.
final double yInitial = computeObjectiveValue(initial);
- if (FastMath.abs(yInitial) <= functionValueAccuracy) {
+ if (AccurateMath.abs(yInitial) <= functionValueAccuracy) {
return initial;
}
// Return the first endpoint if it is good enough.
final double yMin = computeObjectiveValue(min);
- if (FastMath.abs(yMin) <= functionValueAccuracy) {
+ if (AccurateMath.abs(yMin) <= functionValueAccuracy) {
return min;
}
@@ -118,7 +118,7 @@ public class LaguerreSolver extends AbstractPolynomialSolver {
// Return the second endpoint if it is good enough.
final double yMax = computeObjectiveValue(max);
- if (FastMath.abs(yMax) <= functionValueAccuracy) {
+ if (AccurateMath.abs(yMax) <= functionValueAccuracy) {
return max;
}
@@ -242,8 +242,8 @@ public class LaguerreSolver extends AbstractPolynomialSolver {
*/
public boolean isRoot(double min, double max, Complex z) {
if (isSequence(min, z.getReal(), max)) {
- double tolerance = FastMath.max(getRelativeAccuracy() * z.abs(), getAbsoluteAccuracy());
- return (FastMath.abs(z.getImaginary()) <= tolerance) ||
+ double tolerance = AccurateMath.max(getRelativeAccuracy() * z.abs(), getAbsoluteAccuracy());
+ return (AccurateMath.abs(z.getImaginary()) <= tolerance) ||
(z.abs() <= getFunctionValueAccuracy());
}
return false;
@@ -348,7 +348,7 @@ public class LaguerreSolver extends AbstractPolynomialSolver {
d2v = d2v.multiply(Complex.ofCartesian(2.0, 0.0));
// Check for convergence.
- final double tolerance = FastMath.max(relativeAccuracy * z.abs(),
+ final double tolerance = AccurateMath.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 f8ae70e77..ac262cca5 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 @@ package org.apache.commons.math4.legacy.analysis.solvers;
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* This class implements the
@@ -94,15 +94,15 @@ public class MullerSolver extends AbstractUnivariateSolver {
// check for zeros before verifying bracketing
final double fMin = computeObjectiveValue(min);
- if (FastMath.abs(fMin) < functionValueAccuracy) {
+ if (AccurateMath.abs(fMin) < functionValueAccuracy) {
return min;
}
final double fMax = computeObjectiveValue(max);
- if (FastMath.abs(fMax) < functionValueAccuracy) {
+ if (AccurateMath.abs(fMax) < functionValueAccuracy) {
return max;
}
final double fInitial = computeObjectiveValue(initial);
- if (FastMath.abs(fInitial) < functionValueAccuracy) {
+ if (AccurateMath.abs(fInitial) < functionValueAccuracy) {
return initial;
}
@@ -156,17 +156,17 @@ public class MullerSolver extends AbstractUnivariateSolver {
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 + FastMath.sqrt(delta));
- final double xminus = x1 + (-2.0 * y1) / (c1 - FastMath.sqrt(delta));
+ final double xplus = x1 + (-2.0 * y1) / (c1 + AccurateMath.sqrt(delta));
+ final double xminus = x1 + (-2.0 * y1) / (c1 - AccurateMath.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 = FastMath.max(relativeAccuracy * FastMath.abs(x), absoluteAccuracy);
- if (FastMath.abs(x - oldx) <= tolerance ||
- FastMath.abs(y) <= functionValueAccuracy) {
+ final double tolerance = AccurateMath.max(relativeAccuracy * AccurateMath.abs(x), absoluteAccuracy);
+ if (AccurateMath.abs(x - oldx) <= tolerance ||
+ AccurateMath.abs(y) <= functionValueAccuracy) {
return x;
}
@@ -188,7 +188,7 @@ public class MullerSolver extends AbstractUnivariateSolver {
} else {
double xm = 0.5 * (x0 + x2);
double ym = computeObjectiveValue(xm);
- if (FastMath.signum(y0) + FastMath.signum(ym) == 0.0) {
+ if (AccurateMath.signum(y0) + AccurateMath.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 9ab450e29..e137ef822 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 @@ package org.apache.commons.math4.legacy.analysis.solvers;
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* This class implements the
@@ -99,12 +99,12 @@ public class MullerSolver2 extends AbstractUnivariateSolver {
double x0 = min;
double y0 = computeObjectiveValue(x0);
- if (FastMath.abs(y0) < functionValueAccuracy) {
+ if (AccurateMath.abs(y0) < functionValueAccuracy) {
return x0;
}
double x1 = max;
double y1 = computeObjectiveValue(x1);
- if (FastMath.abs(y1) < functionValueAccuracy) {
+ if (AccurateMath.abs(y1) < functionValueAccuracy) {
return x1;
}
@@ -127,12 +127,12 @@ public class MullerSolver2 extends AbstractUnivariateSolver {
final double denominator;
if (delta >= 0.0) {
// choose a denominator larger in magnitude
- double dplus = b + FastMath.sqrt(delta);
- double dminus = b - FastMath.sqrt(delta);
- denominator = FastMath.abs(dplus) > FastMath.abs(dminus) ? dplus : dminus;
+ double dplus = b + AccurateMath.sqrt(delta);
+ double dminus = b - AccurateMath.sqrt(delta);
+ denominator = AccurateMath.abs(dplus) > AccurateMath.abs(dminus) ? dplus : dminus;
} else {
- // take the modulus of (B +/- FastMath.sqrt(delta))
- denominator = FastMath.sqrt(b * b - delta);
+ // take the modulus of (B +/- AccurateMath.sqrt(delta))
+ denominator = AccurateMath.sqrt(b * b - delta);
}
if (denominator != 0) {
x = x2 - 2.0 * c * (x2 - x1) / denominator;
@@ -143,15 +143,15 @@ public class MullerSolver2 extends AbstractUnivariateSolver {
}
} else {
// extremely rare case, get a random number to skip it
- x = min + FastMath.random() * (max - min);
+ x = min + AccurateMath.random() * (max - min);
oldx = Double.POSITIVE_INFINITY;
}
final double y = computeObjectiveValue(x);
// check for convergence
- final double tolerance = FastMath.max(relativeAccuracy * FastMath.abs(x), absoluteAccuracy);
- if (FastMath.abs(x - oldx) <= tolerance ||
- FastMath.abs(y) <= functionValueAccuracy) {
+ final double tolerance = AccurateMath.max(relativeAccuracy * AccurateMath.abs(x), absoluteAccuracy);
+ if (AccurateMath.abs(x - oldx) <= tolerance ||
+ AccurateMath.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 be3c27d46..4b2982635 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 @@ package org.apache.commons.math4.legacy.analysis.solvers;
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Implements
@@ -82,7 +82,7 @@ public class NewtonRaphsonSolver extends AbstractUnivariateDifferentiableSolver
while (true) {
final DerivativeStructure y0 = computeObjectiveValueAndDerivative(x0);
x1 = x0 - (y0.getValue() / y0.getPartialDerivative(1));
- if (FastMath.abs(x1 - x0) <= absoluteAccuracy) {
+ if (AccurateMath.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 40f268063..8b059750f 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 @@ package org.apache.commons.math4.legacy.analysis.solvers;
import org.apache.commons.math4.legacy.exception.NoBracketingException;
import org.apache.commons.math4.legacy.exception.TooManyEvaluationsException;
-import org.apache.commons.math4.legacy.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Implements the
@@ -95,28 +95,28 @@ public class RiddersSolver extends AbstractUnivariateSolver {
// calculate the new root approximation
final double x3 = 0.5 * (x1 + x2);
final double y3 = computeObjectiveValue(x3);
- if (FastMath.abs(y3) <= functionValueAccuracy) {
+ if (AccurateMath.abs(y3) <= functionValueAccuracy) {
return x3;
}
final double delta = 1 - (y1 * y2) / (y3 * y3); // delta > 1 due to bracketing
- final double correction = (FastMath.signum(y2) * FastMath.signum(y3)) *
- (x3 - x1) / FastMath.sqrt(delta);
+ final double correction = (AccurateMath.signum(y2) * AccurateMath.signum(y3)) *
+ (x3 - x1) / AccurateMath.sqrt(delta);
final double x = x3 - correction; // correction != 0
final double y = computeObjectiveValue(x);
// check for convergence
- final double tolerance = FastMath.max(relativeAccuracy * FastMath.abs(x), absoluteAccuracy);
- if (FastMath.abs(x - oldx) <= tolerance) {
+ final double tolerance = AccurateMath.max(relativeAccuracy * AccurateMath.abs(x), absoluteAccuracy);
+ if (AccurateMath.abs(x - oldx) <= tolerance) {
return x;
}
- if (FastMath.abs(y) <= functionValueAccuracy) {
+ if (AccurateMath.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 (FastMath.signum(y1) + FastMath.signum(y) == 0.0) {
+ if (AccurateMath.signum(y1) + AccurateMath.signum(y) == 0.0) {
x2 = x;
y2 = y;
} else {
@@ -126,7 +126,7 @@ public class RiddersSolver extends AbstractUnivariateSolver {
y2 = y3;
}
} else { // x3 < x < x2
- if (FastMath.signum(y2) + FastMath.signum(y) == 0.0) {
+ if (AccurateMath.signum(y2) + AccurateMath.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 0f42598cd..5c1e24143 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 @@ package org.apache.commons.math4.legacy.analysis.solvers;
import org.apache.commons.math4.legacy.exception.NoBracketingException;
import org.apache.commons.math4.legacy.exception.TooManyEvaluationsException;
-import org.apache.commons.math4.legacy.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Implements the Secant method for root-finding (approximating a
@@ -120,13 +120,13 @@ public class SecantSolver extends AbstractUnivariateSolver {
// 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 (FastMath.abs(f1) <= ftol) {
+ if (AccurateMath.abs(f1) <= ftol) {
return x1;
}
// If the current interval is within the given accuracies, we
// are satisfied with the current approximation.
- if (FastMath.abs(x1 - x0) < FastMath.max(rtol * FastMath.abs(x1), atol)) {
+ if (AccurateMath.abs(x1 - x0) < AccurateMath.max(rtol * AccurateMath.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 d03c41f19..d734345e9 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.NotStrictlyPositiveException;
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Utility routines for {@link UnivariateSolver} objects.
@@ -111,11 +111,11 @@ public class UnivariateSolverUtils {
}
// find a very small interval bracketing the root
- final double step = FastMath.max(bracketing.getAbsoluteAccuracy(),
- FastMath.abs(baseRoot * bracketing.getRelativeAccuracy()));
- double xLo = FastMath.max(min, baseRoot - step);
+ final double step = AccurateMath.max(bracketing.getAbsoluteAccuracy(),
+ AccurateMath.abs(baseRoot * bracketing.getRelativeAccuracy()));
+ double xLo = AccurateMath.max(min, baseRoot - step);
double fLo = f.value(xLo);
- double xHi = FastMath.min(max, baseRoot + step);
+ double xHi = AccurateMath.min(max, baseRoot + step);
double fHi = f.value(xHi);
int remainingEval = maxEval - 2;
while (remainingEval > 0) {
@@ -150,14 +150,14 @@ public class UnivariateSolverUtils {
// update the lower bound
if (changeLo) {
- xLo = FastMath.max(min, xLo - step);
+ xLo = AccurateMath.max(min, xLo - step);
fLo = f.value(xLo);
remainingEval--;
}
// update the higher bound
if (changeHi) {
- xHi = FastMath.min(max, xHi + step);
+ xHi = AccurateMath.min(max, xHi + step);
fHi = f.value(xHi);
remainingEval--;
}
@@ -325,8 +325,8 @@ public class UnivariateSolverUtils {
final double previousFb = fb;
delta = r * delta + q;
- a = FastMath.max(initial - delta, lowerBound);
- b = FastMath.min(initial + delta, upperBound);
+ a = AccurateMath.max(initial - delta, lowerBound);
+ b = AccurateMath.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 ab71159d4..78e81c65e 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
@@ -27,7 +27,7 @@ import org.apache.commons.rng.UniformRandomProvider;
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Base class for integer-valued discrete distributions. Default
@@ -94,19 +94,19 @@ public abstract class AbstractIntegerDistribution implements DiscreteDistributio
// use the one-sided Chebyshev inequality to narrow the bracket
// cf. AbstractRealDistribution.inverseCumulativeProbability(double)
final double mu = getMean();
- final double sigma = FastMath.sqrt(getVariance());
+ final double sigma = AccurateMath.sqrt(getVariance());
final boolean chebyshevApplies = !(Double.isInfinite(mu) || Double.isNaN(mu) ||
Double.isInfinite(sigma) || Double.isNaN(sigma) || sigma == 0.0);
if (chebyshevApplies) {
- double k = FastMath.sqrt((1.0 - p) / p);
+ double k = AccurateMath.sqrt((1.0 - p) / p);
double tmp = mu - k * sigma;
if (tmp > lower) {
- lower = ((int) FastMath.ceil(tmp)) - 1;
+ lower = ((int) AccurateMath.ceil(tmp)) - 1;
}
k = 1.0 / k;
tmp = mu + k * sigma;
if (tmp < upper) {
- upper = ((int) FastMath.ceil(tmp)) - 1;
+ upper = ((int) AccurateMath.ceil(tmp)) - 1;
}
}
@@ -175,7 +175,7 @@ public abstract class AbstractIntegerDistribution implements DiscreteDistributio
*/
@Override
public double logProbability(int x) {
- return FastMath.log(probability(x));
+ return AccurateMath.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 069565d04..23cb7be08 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
@@ -28,7 +28,7 @@ import org.apache.commons.rng.UniformRandomProvider;
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.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
* Base class for probability distributions on the reals.
@@ -134,14 +134,14 @@ public abstract class AbstractRealDistribution
}
final double mu = getMean();
- final double sig = FastMath.sqrt(getVariance());
+ final double sig = AccurateMath.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 * FastMath.sqrt((1. - p) / p);
+ lowerBound = mu - sig * AccurateMath.sqrt((1. - p) / p);
} else {
lowerBound = -1.0;
while (cumulativeProbability(lowerBound) >= p) {
@@ -152,7 +152,7 @@ public abstract class AbstractRealDistribution
if (upperBound == Double.POSITIVE_INFINITY) {
if (chebyshevApplies) {
- upperBound = mu + sig * FastMath.sqrt(p / (1. - p));
+ upperBound = mu + sig * AccurateMath.sqrt(p / (1. - p));
} else {
upperBound = 1.0;
while (cumulativeProbability(upperBound) < p) {
@@ -225,7 +225,7 @@ public abstract class AbstractRealDistribution
*/
@Override
public double logDensity(double x) {
- return FastMath.log(density(x));
+ return AccurateMath.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 63da838f0..47814f9d8 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
@@ -42,7 +42,7 @@ import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;
import org.apache.commons.math4.legacy.stat.descriptive.StatisticalSummary;
import org.apache.commons.math4.legacy.stat.descriptive.SummaryStatistics;
-import org.apache.commons.math4.legacy.util.FastMath;
+import org.apache.commons.math4.legacy.core.jdkmath.AccurateMath;
/**
*
*
*
NaN.