JdkMath.java

  1. /*
  2.  * Licensed to the Apache Software Foundation (ASF) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * The ASF licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *      http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.apache.commons.math4.core.jdkmath;

  19. import java.util.function.IntUnaryOperator;
  20. import java.util.function.IntBinaryOperator;
  21. import java.util.function.LongUnaryOperator;
  22. import java.util.function.LongBinaryOperator;
  23. import java.util.function.DoubleUnaryOperator;
  24. import java.util.function.DoubleBinaryOperator;
  25. import java.util.function.DoubleToLongFunction;
  26. import java.util.function.DoubleToIntFunction;
  27. import java.util.function.LongToIntFunction;
  28. import java.util.function.DoubleSupplier;

  30. /**
  31.  * Wrapper for alternative implementations of {@link Math} functions.
  32.  * For example, a call to {@code Math.sin(x)} can be replaced by a call
  33.  * to {@code JdkMath.sin(x)}.
  34.  *
  35.  * <p>
  36.  * This class is a "drop-in" replacement for both Math and StrictMath,
  37.  * up to the <em>minimal</em> JDK version required by this library
  38.  * (meaning that, although the library can be used on <em>more</em>
  39.  * recent JVMs, the {@code JdkMath} class may be missing the methods
  40.  * that were absent in older JDKs).
  41.  *
  42.  * <p>
  43.  * Based on the value, at class initialization, of the system property
  44.  * {@code org.apache.commons.math.jdkmath}, this class redirects to a
  45.  * specific implementation:
  46.  * <ul>
  47.  *  <li>{@code CM}: {@link AccurateMath}</li>
  48.  *  <li>{@code JDK}: {@link Math}</li>
  49.  * </ul>
  50.  * When the property is undefined, {@code CM} is the default value.
  51.  */
  52. public final class JdkMath {
  53.     /** Constant. */
  54.     public static final double PI;
  55.     /** Constant. */
  56.     public static final double E;
  57.     /** Property identifier.. */
  58.     private static final String PROPERTY_KEY = "org.apache.commons.math.jdkmath";
  59.     /** abs(x). */
  60.     private static final IntUnaryOperator ABS_INT;
  61.     /** abs(x). */
  62.     private static final LongUnaryOperator ABS_LONG;
  63.     /** abs(x). */
  64.     private static final FloatUnaryOperator ABS_FLOAT;
  65.     /** abs(x). */
  66.     private static final DoubleUnaryOperator ABS_DOUBLE;
  67.     /** acos(x). */
  68.     private static final DoubleUnaryOperator ACOS;
  69.     /** acosh(x). */
  70.     private static final DoubleUnaryOperator ACOSH;
  71.     /** addExact(x, y). */
  72.     private static final IntBinaryOperator ADDEXACT_INT;
  73.     /** addExact(x, y). */
  74.     private static final LongBinaryOperator ADDEXACT_LONG;
  75.     /** asin(x). */
  76.     private static final DoubleUnaryOperator ASIN;
  77.     /** asinh(x). */
  78.     private static final DoubleUnaryOperator ASINH;
  79.     /** atan(x). */
  80.     private static final DoubleUnaryOperator ATAN;
  81.     /** atan2(x, y). */
  82.     private static final DoubleBinaryOperator ATAN2;
  83.     /** atanh(x). */
  84.     private static final DoubleUnaryOperator ATANH;
  85.     /** cbrt(x). */
  86.     private static final DoubleUnaryOperator CBRT;
  87.     /** ceil(x). */
  88.     private static final DoubleUnaryOperator CEIL;
  89.     /** copySign(x, y). */
  90.     private static final FloatBinaryOperator COPYSIGN_FLOAT;
  91.     /** copySign(x, y). */
  92.     private static final DoubleBinaryOperator COPYSIGN_DOUBLE;
  93.     /** cos(x). */
  94.     private static final DoubleUnaryOperator COS;
  95.     /** cosh(x). */
  96.     private static final DoubleUnaryOperator COSH;
  97.     /** decrementExact(x). */
  98.     private static final IntUnaryOperator DECREMENTEXACT_INT;
  99.     /** decrementExact(x). */
  100.     private static final LongUnaryOperator DECREMENTEXACT_LONG;
  101.     /** exp(x). */
  102.     private static final DoubleUnaryOperator EXP;
  103.     /** expm1(x). */
  104.     private static final DoubleUnaryOperator EXPM1;
  105.     /** floor(x). */
  106.     private static final DoubleUnaryOperator FLOOR;
  107.     /** floorDiv(x, y). */
  108.     private static final IntBinaryOperator FLOORDIV_INT;
  109.     /** floorDiv(x, y). */
  110.     private static final LongBinaryOperator FLOORDIV_LONG;
  111.     /** floorMod(x, y). */
  112.     private static final IntBinaryOperator FLOORMOD_INT;
  113.     /** floorMod(x, y). */
  114.     private static final LongBinaryOperator FLOORMOD_LONG;
  115.     /** getExponent(x). */
  116.     private static final FloatToIntFunction GETEXPONENT_FLOAT;
  117.     /** getExponent(x). */
  118.     private static final DoubleToIntFunction GETEXPONENT_DOUBLE;
  119.     /** hypot(x, y). */
  120.     private static final DoubleBinaryOperator HYPOT;
  121.     /** IEEEremainder(x, y). */
  122.     private static final DoubleBinaryOperator IEEEREMAINDER;
  123.     /** incrementExact(x). */
  124.     private static final IntUnaryOperator INCREMENTEXACT_INT;
  125.     /** incrementExact(x). */
  126.     private static final LongUnaryOperator INCREMENTEXACT_LONG;
  127.     /** log(x). */
  128.     private static final DoubleUnaryOperator LOG;
  129.     /** log10(x). */
  130.     private static final DoubleUnaryOperator LOG10;
  131.     /** log1p(x). */
  132.     private static final DoubleUnaryOperator LOG1P;
  133.     /** max(x, y). */
  134.     private static final IntBinaryOperator MAX_INT;
  135.     /** max(x, y). */
  136.     private static final LongBinaryOperator MAX_LONG;
  137.     /** max(x, y). */
  138.     private static final FloatBinaryOperator MAX_FLOAT;
  139.     /** max(x, y). */
  140.     private static final DoubleBinaryOperator MAX_DOUBLE;
  141.     /** min(x, y). */
  142.     private static final IntBinaryOperator MIN_INT;
  143.     /** min(x, y). */
  144.     private static final LongBinaryOperator MIN_LONG;
  145.     /** min(x, y). */
  146.     private static final FloatBinaryOperator MIN_FLOAT;
  147.     /** min(x, y). */
  148.     private static final DoubleBinaryOperator MIN_DOUBLE;
  149.     /** multiplyExact(x, y). */
  150.     private static final IntBinaryOperator MULTIPLYEXACT_INT;
  151.     /** multiplyExact(x, y). */
  152.     private static final LongBinaryOperator MULTIPLYEXACT_LONG;
  153.     /** negateExact(x). */
  154.     private static final IntUnaryOperator NEGATEEXACT_INT;
  155.     /** negateExact(x). */
  156.     private static final LongUnaryOperator NEGATEEXACT_LONG;
  157.     /** nextAfter(x, y). */
  158.     private static final FloatDouble2FloatOperator NEXTAFTER_FLOAT;
  159.     /** nextAfter(x, y). */
  160.     private static final DoubleBinaryOperator NEXTAFTER_DOUBLE;
  161.     /** nextDown(x). */
  162.     private static final FloatUnaryOperator NEXTDOWN_FLOAT;
  163.     /** nextDown(x). */
  164.     private static final DoubleUnaryOperator NEXTDOWN_DOUBLE;
  165.     /** nextUp(x). */
  166.     private static final FloatUnaryOperator NEXTUP_FLOAT;
  167.     /** nextUp(x). */
  168.     private static final DoubleUnaryOperator NEXTUP_DOUBLE;
  169.     /** pow(x, y). */
  170.     private static final DoubleBinaryOperator POW;
  171.     /** random(). */
  172.     private static final DoubleSupplier RANDOM;
  173.     /** rint(x). */
  174.     private static final DoubleUnaryOperator RINT;
  175.     /** round(x). */
  176.     private static final DoubleToLongFunction ROUND_DOUBLE;
  177.     /** round(x). */
  178.     private static final FloatToIntFunction ROUND_FLOAT;
  179.     /** scalb(x, y). */
  180.     private static final DoubleInt2DoubleOperator SCALB_DOUBLE;
  181.     /** scalb(x, y). */
  182.     private static final FloatInt2FloatOperator SCALB_FLOAT;
  183.     /** signum(x). */
  184.     private static final FloatUnaryOperator SIGNUM_FLOAT;
  185.     /** signum(x). */
  186.     private static final DoubleUnaryOperator SIGNUM_DOUBLE;
  187.     /** sin(x). */
  188.     private static final DoubleUnaryOperator SIN;
  189.     /** sinh(x). */
  190.     private static final DoubleUnaryOperator SINH;
  191.     /** sqrt(x). */
  192.     private static final DoubleUnaryOperator SQRT;
  193.     /** subtractExact(x, y). */
  194.     private static final IntBinaryOperator SUBTRACTEXACT_INT;
  195.     /** subtractExact(x, y). */
  196.     private static final LongBinaryOperator SUBTRACTEXACT_LONG;
  197.     /** tan(x). */
  198.     private static final DoubleUnaryOperator TAN;
  199.     /** tanh(x). */
  200.     private static final DoubleUnaryOperator TANH;
  201.     /** toDegrees(x). */
  202.     private static final DoubleUnaryOperator TODEGREES;
  203.     /** toIntExact(x). */
  204.     private static final LongToIntFunction TOINTEXACT;
  205.     /** toRadians(x). */
  206.     private static final DoubleUnaryOperator TORADIANS;
  207.     /** ulp(x). */
  208.     private static final DoubleUnaryOperator ULP_DOUBLE;
  209.     /** ulp(x). */
  210.     private static final FloatUnaryOperator ULP_FLOAT;

  212.     /** Available implementations of {@link Math} functions. */
  213.     public enum Impl {
  214.         /** {@link AccurateMath Commons Math}. */
  215.         CM,
  216.         /** {@link Math JDK}. */
  217.         JDK
  218.     }

  220.     static {
  221.         final String prop = System.getProperty(PROPERTY_KEY);
  222.         final Impl impl = prop != null ?
  223.             Impl.valueOf(prop) :
  224.             Impl.CM;


  227.         switch (impl) {
  228.         case CM:
  229.             PI = AccurateMath.PI;
  230.             E = AccurateMath.E;
  231.             ABS_INT = AccurateMath::abs;
  232.             ABS_LONG = AccurateMath::abs;
  233.             ABS_FLOAT = AccurateMath::abs;
  234.             ABS_DOUBLE = AccurateMath::abs;
  235.             ACOS = AccurateMath::acos;
  236.             ACOSH = AccurateMath::acosh;
  237.             ADDEXACT_INT = AccurateMath::addExact;
  238.             ADDEXACT_LONG = AccurateMath::addExact;
  239.             ASIN = AccurateMath::asin;
  240.             ASINH = AccurateMath::asinh;
  241.             ATAN = AccurateMath::atan;
  242.             ATAN2 = AccurateMath::atan2;
  243.             ATANH = AccurateMath::atanh;
  244.             CBRT = AccurateMath::cbrt;
  245.             CEIL = AccurateMath::ceil;
  246.             COPYSIGN_FLOAT = AccurateMath::copySign;
  247.             COPYSIGN_DOUBLE = AccurateMath::copySign;
  248.             COS = AccurateMath::cos;
  249.             COSH = AccurateMath::cosh;
  250.             DECREMENTEXACT_INT = AccurateMath::decrementExact;
  251.             DECREMENTEXACT_LONG = AccurateMath::decrementExact;
  252.             EXP = AccurateMath::exp;
  253.             EXPM1 = AccurateMath::expm1;
  254.             FLOOR = AccurateMath::floor;
  255.             FLOORDIV_INT = AccurateMath::floorDiv;
  256.             FLOORDIV_LONG = AccurateMath::floorDiv;
  257.             FLOORMOD_INT = AccurateMath::floorMod;
  258.             FLOORMOD_LONG = AccurateMath::floorMod;
  259.             GETEXPONENT_FLOAT = AccurateMath::getExponent;
  260.             GETEXPONENT_DOUBLE = AccurateMath::getExponent;
  261.             HYPOT = AccurateMath::hypot;
  262.             IEEEREMAINDER = AccurateMath::IEEEremainder;
  263.             INCREMENTEXACT_INT = AccurateMath::incrementExact;
  264.             INCREMENTEXACT_LONG = AccurateMath::incrementExact;
  265.             LOG = AccurateMath::log;
  266.             LOG10 = AccurateMath::log10;
  267.             LOG1P = AccurateMath::log1p;
  268.             MAX_INT = AccurateMath::max;
  269.             MAX_LONG = AccurateMath::max;
  270.             MAX_FLOAT = AccurateMath::max;
  271.             MAX_DOUBLE = AccurateMath::max;
  272.             MIN_INT = AccurateMath::min;
  273.             MIN_LONG = AccurateMath::min;
  274.             MIN_FLOAT = AccurateMath::min;
  275.             MIN_DOUBLE = AccurateMath::min;
  276.             MULTIPLYEXACT_INT = AccurateMath::multiplyExact;
  277.             MULTIPLYEXACT_LONG = AccurateMath::multiplyExact;
  278.             NEGATEEXACT_INT = Math::negateExact; // Not implemented.
  279.             NEGATEEXACT_LONG = Math::negateExact; // Not implemented.
  280.             NEXTAFTER_FLOAT = AccurateMath::nextAfter;
  281.             NEXTAFTER_DOUBLE = AccurateMath::nextAfter;
  282.             NEXTDOWN_FLOAT = AccurateMath::nextDown;
  283.             NEXTDOWN_DOUBLE = AccurateMath::nextDown;
  284.             NEXTUP_FLOAT = AccurateMath::nextUp;
  285.             NEXTUP_DOUBLE = AccurateMath::nextUp;
  286.             POW = AccurateMath::pow;
  287.             RANDOM = Math::random; // Not implemented.
  288.             RINT = AccurateMath::rint;
  289.             ROUND_DOUBLE = AccurateMath::round;
  290.             ROUND_FLOAT = AccurateMath::round;
  291.             SCALB_DOUBLE = AccurateMath::scalb;
  292.             SCALB_FLOAT = AccurateMath::scalb;
  293.             SIGNUM_DOUBLE = AccurateMath::signum;
  294.             SIGNUM_FLOAT = AccurateMath::signum;
  295.             SQRT = Math::sqrt; // Not implemented.
  296.             SIN = AccurateMath::sin;
  297.             SINH = AccurateMath::sinh;
  298.             SUBTRACTEXACT_INT = AccurateMath::subtractExact;
  299.             SUBTRACTEXACT_LONG = AccurateMath::subtractExact;
  300.             TAN = AccurateMath::tan;
  301.             TANH = AccurateMath::tanh;
  302.             TODEGREES = AccurateMath::toDegrees;
  303.             TOINTEXACT = AccurateMath::toIntExact;
  304.             TORADIANS = AccurateMath::toRadians;
  305.             ULP_DOUBLE = AccurateMath::ulp;
  306.             ULP_FLOAT = AccurateMath::ulp;
  307.             break;

  309.         case JDK:
  310.             PI = Math.PI;
  311.             E = Math.E;
  312.             ABS_INT = Math::abs;
  313.             ABS_LONG = Math::abs;
  314.             ABS_FLOAT = Math::abs;
  315.             ABS_DOUBLE = Math::abs;
  316.             ACOS = Math::acos;
  317.             ACOSH = AccurateMath::acosh; // Not implemented.
  318.             ADDEXACT_INT = Math::addExact;
  319.             ADDEXACT_LONG = Math::addExact;
  320.             ASIN = Math::asin;
  321.             ASINH = AccurateMath::asinh; // Not implemented.
  322.             ATAN = Math::atan;
  323.             ATAN2 = Math::atan2;
  324.             ATANH = AccurateMath::atanh; // Not implemented.
  325.             CBRT = Math::cbrt;
  326.             CEIL = Math::ceil;
  327.             COPYSIGN_FLOAT = Math::copySign;
  328.             COPYSIGN_DOUBLE = Math::copySign;
  329.             COS = Math::cos;
  330.             COSH = Math::cosh;
  331.             DECREMENTEXACT_INT = Math::decrementExact;
  332.             DECREMENTEXACT_LONG = Math::decrementExact;
  333.             EXP = Math::exp;
  334.             EXPM1 = Math::expm1;
  335.             FLOOR = Math::floor;
  336.             FLOORDIV_INT = Math::floorDiv;
  337.             FLOORDIV_LONG = Math::floorDiv;
  338.             FLOORMOD_INT = Math::floorMod;
  339.             FLOORMOD_LONG = Math::floorMod;
  340.             GETEXPONENT_FLOAT = Math::getExponent;
  341.             GETEXPONENT_DOUBLE = Math::getExponent;
  342.             HYPOT = Math::hypot;
  343.             IEEEREMAINDER = Math::IEEEremainder;
  344.             INCREMENTEXACT_INT = Math::incrementExact;
  345.             INCREMENTEXACT_LONG = Math::incrementExact;
  346.             LOG = Math::log;
  347.             LOG10 = Math::log10;
  348.             LOG1P = Math::log1p;
  349.             MAX_INT = Math::max;
  350.             MAX_LONG = Math::max;
  351.             MAX_FLOAT = Math::max;
  352.             MAX_DOUBLE = Math::max;
  353.             MIN_INT = Math::min;
  354.             MIN_LONG = Math::min;
  355.             MIN_FLOAT = Math::min;
  356.             MIN_DOUBLE = Math::min;
  357.             MULTIPLYEXACT_INT = Math::multiplyExact;
  358.             MULTIPLYEXACT_LONG = Math::multiplyExact;
  359.             NEGATEEXACT_INT = Math::negateExact;
  360.             NEGATEEXACT_LONG = Math::negateExact;
  361.             NEXTAFTER_FLOAT = Math::nextAfter;
  362.             NEXTAFTER_DOUBLE = Math::nextAfter;
  363.             NEXTDOWN_FLOAT = Math::nextDown;
  364.             NEXTDOWN_DOUBLE = Math::nextDown;
  365.             NEXTUP_FLOAT = Math::nextUp;
  366.             NEXTUP_DOUBLE = Math::nextUp;
  367.             POW = Math::pow;
  368.             RANDOM = Math::random;
  369.             RINT = Math::rint;
  370.             ROUND_DOUBLE = Math::round;
  371.             ROUND_FLOAT = Math::round;
  372.             SCALB_DOUBLE = Math::scalb;
  373.             SCALB_FLOAT = Math::scalb;
  374.             SIGNUM_DOUBLE = Math::signum;
  375.             SIGNUM_FLOAT = Math::signum;
  376.             SIN = Math::sin;
  377.             SINH = Math::sinh;
  378.             SQRT = Math::sqrt;
  379.             SUBTRACTEXACT_INT = Math::subtractExact;
  380.             SUBTRACTEXACT_LONG = Math::subtractExact;
  381.             TAN = Math::tan;
  382.             TANH = Math::tanh;
  383.             TODEGREES = Math::toDegrees;
  384.             TOINTEXACT = Math::toIntExact;
  385.             TORADIANS = Math::toRadians;
  386.             ULP_DOUBLE = Math::ulp;
  387.             ULP_FLOAT = Math::ulp;
  388.             break;

  390.         default:
  391.             throw new IllegalStateException("Internal error"); // Should never happen.
  392.         }
  393.     }

  395.     /** Utility class. */
  396.     private JdkMath() {}

  398.     /**
  399.      * @param x Number.
  400.      * @return abs(x).
  401.      *
  402.      * @see Math#abs(int)
  403.      */
  404.     public static int abs(int x) {
  405.         return ABS_INT.applyAsInt(x);
  406.     }

  408.     /**
  409.      * @param x Number.
  410.      * @return abs(x).
  411.      *
  412.      * @see Math#abs(long)
  413.      */
  414.     public static long abs(long x) {
  415.         return ABS_LONG.applyAsLong(x);
  416.     }

  418.     /**
  419.      * @param x Number.
  420.      * @return abs(x).
  421.      *
  422.      * @see Math#abs(float)
  423.      */
  424.     public static float abs(float x) {
  425.         return ABS_FLOAT.applyAsFloat(x);
  426.     }

  428.     /**
  429.      * @param x Number.
  430.      * @return abs(x).
  431.      *
  432.      * @see Math#abs(double)
  433.      */
  434.     public static double abs(double x) {
  435.         return ABS_DOUBLE.applyAsDouble(x);
  436.     }

  438.     /**
  439.      * @param x Number.
  440.      * @return acos(x).
  441.      *
  442.      * @see Math#acos(double)
  443.      */
  444.     public static double acos(double x) {
  445.         return ACOS.applyAsDouble(x);
  446.     }

  448.     /**
  449.      * @param x Number.
  450.      * @return acosh(x).
  451.      */
  452.     public static double acosh(double x) {
  453.         return ACOSH.applyAsDouble(x);
  454.     }

  456.     /**
  457.      * @param x Number.
  458.      * @param y Number.
  459.      * @return addExact(x, y).
  460.      *
  461.      * @see Math#addExact(int,int)
  462.      */
  463.     public static int addExact(int x,
  464.                                int y) {
  465.         return ADDEXACT_INT.applyAsInt(x, y);
  466.     }

  468.     /**
  469.      * @param x Number.
  470.      * @param y Number.
  471.      * @return addExact(x, y).
  472.      *
  473.      * @see Math#addExact(long,long)
  474.      */
  475.     public static long addExact(long x,
  476.                                 long y) {
  477.         return ADDEXACT_LONG.applyAsLong(x, y);
  478.     }

  480.     /**
  481.      * @param x Number.
  482.      * @return asin(x).
  483.      *
  484.      * @see Math#asin(double)
  485.      */
  486.     public static double asin(double x) {
  487.         return ASIN.applyAsDouble(x);
  488.     }

  490.     /**
  491.      * @param x Number.
  492.      * @return asinh(x).
  493.      */
  494.     public static double asinh(double x) {
  495.         return ASINH.applyAsDouble(x);
  496.     }

  498.     /**
  499.      * @param x Number.
  500.      * @return atan(x).
  501.      *
  502.      * @see Math#atan(double)
  503.      */
  504.     public static double atan(double x) {
  505.         return ATAN.applyAsDouble(x);
  506.     }

  508.     /**
  509.      * @param y Number.
  510.      * @param x Number.
  511.      * @return atan2(y, x).
  512.      *
  513.      * @see Math#atan2(double,double)
  514.      */
  515.     public static double atan2(double y,
  516.                                double x) {
  517.         return ATAN2.applyAsDouble(y, x);
  518.     }

  520.     /**
  521.      * @param x Number.
  522.      * @return atanh(x).
  523.      */
  524.     public static double atanh(double x) {
  525.         return ATANH.applyAsDouble(x);
  526.     }

  528.     /**
  529.      * @param x Number.
  530.      * @return cbrt(x).
  531.      *
  532.      * @see Math#cbrt(double)
  533.      */
  534.     public static double cbrt(double x) {
  535.         return CBRT.applyAsDouble(x);
  536.     }

  538.     /**
  539.      * @param x Number.
  540.      * @return ceil(x).
  541.      *
  542.      * @see Math#ceil(double)
  543.      */
  544.     public static double ceil(double x) {
  545.         return CEIL.applyAsDouble(x);
  546.     }

  548.     /**
  549.      * @param x Number.
  550.      * @param y Number.
  551.      * @return copySign(x, y).
  552.      *
  553.      * @see Math#copySign(float,float)
  554.      */
  555.     public static float copySign(float x,
  556.                                  float y) {
  557.         return COPYSIGN_FLOAT.applyAsFloat(x, y);
  558.     }

  560.     /**
  561.      * @param x Number.
  562.      * @param y Number.
  563.      * @return copySign(x, y).
  564.      *
  565.      * @see Math#copySign(double,double)
  566.      */
  567.     public static double copySign(double x,
  568.                                   double y) {
  569.         return COPYSIGN_DOUBLE.applyAsDouble(x, y);
  570.     }

  572.     /**
  573.      * @param x Number.
  574.      * @return cos(x).
  575.      *
  576.      * @see Math#cos(double)
  577.      */
  578.     public static double cos(double x) {
  579.         return COS.applyAsDouble(x);
  580.     }

  582.     /**
  583.      * @param x Number.
  584.      * @return cosh(x).
  585.      *
  586.      * @see Math#cosh(double)
  587.      */
  588.     public static double cosh(double x) {
  589.         return COSH.applyAsDouble(x);
  590.     }

  592.     /**
  593.      * @param x Number.
  594.      * @return decrementExact(x).
  595.      *
  596.      * @see Math#decrementExact(int)
  597.      */
  598.     public static int decrementExact(int x) {
  599.         return DECREMENTEXACT_INT.applyAsInt(x);
  600.     }

  602.     /**
  603.      * @param x Number.
  604.      * @return decrementExact(x).
  605.      *
  606.      * @see Math#decrementExact(long)
  607.      */
  608.     public static long decrementExact(long x) {
  609.         return DECREMENTEXACT_LONG.applyAsLong(x);
  610.     }

  612.     /**
  613.      * @param x Number.
  614.      * @return exp(x).
  615.      *
  616.      * @see Math#exp(double)
  617.      */
  618.     public static double exp(double x) {
  619.         return EXP.applyAsDouble(x);
  620.     }

  622.     /**
  623.      * @param x Number.
  624.      * @return expm1(x).
  625.      *
  626.      * @see Math#expm1(double)
  627.      */
  628.     public static double expm1(double x) {
  629.         return EXPM1.applyAsDouble(x);
  630.     }

  632.     /**
  633.      * @param x Number.
  634.      * @return floor(x).
  635.      *
  636.      * @see Math#floor(double)
  637.      */
  638.     public static double floor(double x) {
  639.         return FLOOR.applyAsDouble(x);
  640.     }

  642.     /**
  643.      * @param x Number.
  644.      * @param y Number.
  645.      * @return floorDiv(x, y).
  646.      *
  647.      * @see Math#floorDiv(int,int)
  648.      */
  649.     public static int floorDiv(int x,
  650.                                int y) {
  651.         return FLOORDIV_INT.applyAsInt(x, y);
  652.     }

  654.     /**
  655.      * @param x Number.
  656.      * @param y Number.
  657.      * @return floorDiv(x, y).
  658.      *
  659.      * @see Math#floorDiv(long,long)
  660.      */
  661.     public static long floorDiv(long x,
  662.                                 long y) {
  663.         return FLOORDIV_LONG.applyAsLong(x, y);
  664.     }

  666.     /**
  667.      * @param x Number.
  668.      * @param y Number.
  669.      * @return floorMod(x, y).
  670.      *
  671.      * @see Math#floorMod(int,int)
  672.      */
  673.     public static int floorMod(int x,
  674.                                int y) {
  675.         return FLOORMOD_INT.applyAsInt(x, y);
  676.     }

  678.     /**
  679.      * @param x Number.
  680.      * @param y Number.
  681.      * @return floorMod(x, y).
  682.      *
  683.      * @see Math#floorMod(long,long)
  684.      */
  685.     public static long floorMod(long x,
  686.                                 long y) {
  687.         return FLOORMOD_LONG.applyAsLong(x, y);
  688.     }

  690.     /**
  691.      * @param x Number.
  692.      * @return getExponent(x).
  693.      *
  694.      * @see Math#getExponent(float)
  695.      */
  696.     public static int getExponent(float x) {
  697.         return GETEXPONENT_FLOAT.applyAsInt(x);
  698.     }

  700.     /**
  701.      * @param x Number.
  702.      * @return getExponent(x).
  703.      *
  704.      * @see Math#getExponent(double)
  705.      */
  706.     public static int getExponent(double x) {
  707.         return GETEXPONENT_DOUBLE.applyAsInt(x);
  708.     }

  710.     /**
  711.      * @param x Number.
  712.      * @param y Number.
  713.      * @return hypot(x, y).
  714.      *
  715.      * @see Math#hypot(double,double)
  716.      */
  717.     public static double hypot(double x,
  718.                                double y) {
  719.         return HYPOT.applyAsDouble(x, y);
  720.     }

  722.     /**
  723.      * @param x Number.
  724.      * @param y Number.
  725.      * @return IEEEremainder(x, y).
  726.      *
  727.      * @see Math#IEEEremainder(double,double)
  728.      */
  729.     public static double IEEEremainder(double x,
  730.                                        double y) {
  731.         return IEEEREMAINDER.applyAsDouble(x, y);
  732.     }

  734.     /**
  735.      * @param x Number.
  736.      * @return incrementExact(x).
  737.      *
  738.      * @see Math#incrementExact(int)
  739.      */
  740.     public static int incrementExact(int x) {
  741.         return INCREMENTEXACT_INT.applyAsInt(x);
  742.     }

  744.     /**
  745.      * @param x Number.
  746.      * @return incrementExact(x).
  747.      *
  748.      * @see Math#incrementExact(long)
  749.      */
  750.     public static long incrementExact(long x) {
  751.         return INCREMENTEXACT_LONG.applyAsLong(x);
  752.     }

  754.     /**
  755.      * @param x Number.
  756.      * @return log(x).
  757.      *
  758.      * @see Math#log(double)
  759.      */
  760.     public static double log(double x) {
  761.         return LOG.applyAsDouble(x);
  762.     }

  764.     /**
  765.      * @param x Number.
  766.      * @return log10(x).
  767.      *
  768.      * @see Math#log10(double)
  769.      */
  770.     public static double log10(double x) {
  771.         return LOG10.applyAsDouble(x);
  772.     }

  774.     /**
  775.      * @param x Number.
  776.      * @return log1p(x).
  777.      *
  778.      * @see Math#log1p(double)
  779.      */
  780.     public static double log1p(double x) {
  781.         return LOG1P.applyAsDouble(x);
  782.     }

  784.     /**
  785.      * @param x Number.
  786.      * @param y Number.
  787.      * @return max(x, y).
  788.      *
  789.      * @see Math#max(int,int)
  790.      */
  791.     public static int max(int x,
  792.                           int y) {
  793.         return MAX_INT.applyAsInt(x, y);
  794.     }

  796.     /**
  797.      * @param x Number.
  798.      * @param y Number.
  799.      * @return max(x, y).
  800.      *
  801.      * @see Math#max(long,long)
  802.      */
  803.     public static long max(long x,
  804.                            long y) {
  805.         return MAX_LONG.applyAsLong(x, y);
  806.     }

  808.     /**
  809.      * @param x Number.
  810.      * @param y Number.
  811.      * @return max(x, y).
  812.      *
  813.      * @see Math#max(float,float)
  814.      */
  815.     public static float max(float x,
  816.                             float y) {
  817.         return MAX_FLOAT.applyAsFloat(x, y);
  818.     }

  820.     /**
  821.      * @param x Number.
  822.      * @param y Number.
  823.      * @return max(x, y).
  824.      *
  825.      * @see Math#max(double,double)
  826.      */
  827.     public static double max(double x,
  828.                              double y) {
  829.         return MAX_DOUBLE.applyAsDouble(x, y);
  830.     }

  832.     /**
  833.      * @param x Number.
  834.      * @param y Number.
  835.      * @return min(x, y).
  836.      *
  837.      * @see Math#min(int,int)
  838.      */
  839.     public static int min(int x,
  840.                           int y) {
  841.         return MIN_INT.applyAsInt(x, y);
  842.     }

  844.     /**
  845.      * @param x Number.
  846.      * @param y Number.
  847.      * @return min(x, y).
  848.      *
  849.      * @see Math#min(long,long)
  850.      */
  851.     public static long min(long x,
  852.                            long y) {
  853.         return MIN_LONG.applyAsLong(x, y);
  854.     }

  856.     /**
  857.      * @param x Number.
  858.      * @param y Number.
  859.      * @return min(x, y).
  860.      *
  861.      * @see Math#min(float,float)
  862.      */
  863.     public static float min(float x,
  864.                             float y) {
  865.         return MIN_FLOAT.applyAsFloat(x, y);
  866.     }

  868.     /**
  869.      * @param x Number.
  870.      * @param y Number.
  871.      * @return min(x, y).
  872.      *
  873.      * @see Math#min(double,double)
  874.      */
  875.     public static double min(double x,
  876.                              double y) {
  877.         return MIN_DOUBLE.applyAsDouble(x, y);
  878.     }

  880.     /**
  881.      * @param x Number.
  882.      * @param y Number.
  883.      * @return multiplyExact(x, y).
  884.      *
  885.      * @see Math#multiplyExact(int,int)
  886.      */
  887.     public static int multiplyExact(int x,
  888.                                     int y) {
  889.         return MULTIPLYEXACT_INT.applyAsInt(x, y);
  890.     }

  892.     /**
  893.      * @param x Number.
  894.      * @param y Number.
  895.      * @return multiplyExact(x, y).
  896.      *
  897.      * @see Math#multiplyExact(long,long)
  898.      */
  899.     public static long multiplyExact(long x,
  900.                                      long y) {
  901.         return MULTIPLYEXACT_LONG.applyAsLong(x, y);
  902.     }

  904.     /**
  905.      * @param x Number.
  906.      * @return negateExact(x).
  907.      *
  908.      * @see Math#negateExact(int)
  909.      */
  910.     public static int negateExact(int x) {
  911.         return NEGATEEXACT_INT.applyAsInt(x);
  912.     }

  914.     /**
  915.      * @param x Number.
  916.      * @return negateExact(x).
  917.      *
  918.      * @see Math#negateExact(long)
  919.      */
  920.     public static long negateExact(long x) {
  921.         return NEGATEEXACT_LONG.applyAsLong(x);
  922.     }

  924.     /**
  925.      * @param x Number.
  926.      * @param y Number.
  927.      * @return nextAfter(x, y).
  928.      *
  929.      * @see Math#nextAfter(double, double)
  930.      */
  931.     public static double nextAfter(double x,
  932.                                    double y) {
  933.         return NEXTAFTER_DOUBLE.applyAsDouble(x, y);
  934.     }

  936.     /**
  937.      * @param x Number.
  938.      * @param y Number.
  939.      * @return nextAfter(x, y).
  940.      *
  941.      * @see Math#nextAfter(float,double)
  942.      */
  943.     public static float nextAfter(float x,
  944.                                   double y) {
  945.         return NEXTAFTER_FLOAT.applyAsFloat(x, y);
  946.     }

  948.     /**
  949.      * @param x Number.
  950.      * @return nextDown(x).
  951.      *
  952.      * @see Math#nextDown(double)
  953.      */
  954.     public static double nextDown(double x) {
  955.         return NEXTDOWN_DOUBLE.applyAsDouble(x);
  956.     }

  958.     /**
  959.      * @param x Number.
  960.      * @return nextDown(x).
  961.      *
  962.      * @see Math#nextDown(float)
  963.      */
  964.     public static float nextDown(float x) {
  965.         return NEXTDOWN_FLOAT.applyAsFloat(x);
  966.     }

  968.     /**
  969.      * @param x Number.
  970.      * @return nextUp(x).
  971.      *
  972.      * @see Math#nextUp(double)
  973.      */
  974.     public static double nextUp(double x) {
  975.         return NEXTUP_DOUBLE.applyAsDouble(x);
  976.     }

  978.     /**
  979.      * @param x Number.
  980.      * @return nextUp(x).
  981.      *
  982.      * @see Math#nextUp(float)
  983.      */
  984.     public static float nextUp(float x) {
  985.         return NEXTUP_FLOAT.applyAsFloat(x);
  986.     }

  988.     /**
  989.      * @param x Number.
  990.      * @param y Number.
  991.      * @return pow(x, y).
  992.      *
  993.      * @see Math#pow(double,double)
  994.      */
  995.     public static double pow(double x,
  996.                              double y) {
  997.         return POW.applyAsDouble(x, y);
  998.     }

  1000.     /**
  1001.      * @return a random number between 0 and 1.
  1002.      *
  1003.      * @see Math#random()
  1004.      */
  1005.     public static double random() {
  1006.         return RANDOM.getAsDouble();
  1007.     }

  1009.     /**
  1010.      * @param x Number.
  1011.      * @return rint(x).
  1012.      *
  1013.      * @see Math#rint(double)
  1014.      */
  1015.     public static double rint(double x) {
  1016.         return RINT.applyAsDouble(x);
  1017.     }

  1019.     /**
  1020.      * @param x Number.
  1021.      * @return round(x).
  1022.      *
  1023.      * @see Math#round(float)
  1024.      */
  1025.     public static int round(float x) {
  1026.         return ROUND_FLOAT.applyAsInt(x);
  1027.     }

  1029.     /**
  1030.      * @param x Number.
  1031.      * @return round(x).
  1032.      *
  1033.      * @see Math#round(double)
  1034.      */
  1035.     public static long round(double x) {
  1036.         return ROUND_DOUBLE.applyAsLong(x);
  1037.     }

  1039.     /**
  1040.      * @param x Number.
  1041.      * @param y Number.
  1042.      * @return scalb(x, y).
  1043.      *
  1044.      * @see Math#scalb(double,int)
  1045.      */
  1046.     public static double scalb(double x,
  1047.                                int y) {
  1048.         return SCALB_DOUBLE.applyAsDouble(x, y);
  1049.     }

  1051.     /**
  1052.      * @param x Number.
  1053.      * @param y Number.
  1054.      * @return scalb(x, y).
  1055.      *
  1056.      * @see Math#scalb(float,int)
  1057.      */
  1058.     public static float scalb(float x,
  1059.                               int y) {
  1060.         return SCALB_FLOAT.applyAsFloat(x, y);
  1061.     }

  1063.     /**
  1064.      * @param x Number.
  1065.      * @return signum(x).
  1066.      *
  1067.      * @see Math#signum(double)
  1068.      */
  1069.     public static double signum(double x) {
  1070.         return SIGNUM_DOUBLE.applyAsDouble(x);
  1071.     }

  1073.     /**
  1074.      * @param x Number.
  1075.      * @return signum(x).
  1076.      *
  1077.      * @see Math#signum(float)
  1078.      */
  1079.     public static float signum(float x) {
  1080.         return SIGNUM_FLOAT.applyAsFloat(x);
  1081.     }

  1083.     /**
  1084.      * @param x Number.
  1085.      * @return sin(x).
  1086.      *
  1087.      * @see Math#sin(double)
  1088.      */
  1089.     public static double sin(double x) {
  1090.         return SIN.applyAsDouble(x);
  1091.     }

  1093.     /**
  1094.      * @param x Number.
  1095.      * @return sinh(x).
  1096.      *
  1097.      * @see Math#sinh(double)
  1098.      */
  1099.     public static double sinh(double x) {
  1100.         return SINH.applyAsDouble(x);
  1101.     }

  1103.     /**
  1104.      * @param x Number.
  1105.      * @return sqrt(x).
  1106.      *
  1107.      * @see Math#sqrt(double)
  1108.      */
  1109.     public static double sqrt(double x) {
  1110.         return SQRT.applyAsDouble(x);
  1111.     }

  1113.     /**
  1114.      * @param x Number.
  1115.      * @param y Number.
  1116.      * @return subtractExact(x, y).
  1117.      *
  1118.      * @see Math#subtractExact(int,int)
  1119.      */
  1120.     public static int subtractExact(int x,
  1121.                                     int y) {
  1122.         return SUBTRACTEXACT_INT.applyAsInt(x, y);
  1123.     }

  1125.     /**
  1126.      * @param x Number.
  1127.      * @param y Number.
  1128.      * @return subtractExact(x, y).
  1129.      *
  1130.      * @see Math#subtractExact(long,long)
  1131.      */
  1132.     public static long subtractExact(long x,
  1133.                                      long y) {
  1134.         return SUBTRACTEXACT_LONG.applyAsLong(x, y);
  1135.     }

  1137.     /**
  1138.      * @param x Number.
  1139.      * @return tan(x).
  1140.      *
  1141.      * @see Math#tan(double)
  1142.      */
  1143.     public static double tan(double x) {
  1144.         return TAN.applyAsDouble(x);
  1145.     }

  1147.     /**
  1148.      * @param x Number.
  1149.      * @return tanh(x).
  1150.      *
  1151.      * @see Math#tanh(double)
  1152.      */
  1153.     public static double tanh(double x) {
  1154.         return TANH.applyAsDouble(x);
  1155.     }

  1157.     /**
  1158.      * @param x Number.
  1159.      * @return toDegrees(x).
  1160.      *
  1161.      * @see Math#toDegrees(double)
  1162.      */
  1163.     public static double toDegrees(double x) {
  1164.         return TODEGREES.applyAsDouble(x);
  1165.     }

  1167.     /**
  1168.      * @param x Number.
  1169.      * @return toIntExact(x).
  1170.      *
  1171.      * @see Math#toIntExact(long)
  1172.      */
  1173.     public static int toIntExact(long x) {
  1174.         return TOINTEXACT.applyAsInt(x);
  1175.     }

  1177.     /**
  1178.      * @param x Number.
  1179.      * @return toRadians(x).
  1180.      *
  1181.      * @see Math#toRadians(double)
  1182.      */
  1183.     public static double toRadians(double x) {
  1184.         return TORADIANS.applyAsDouble(x);
  1185.     }

  1187.     /**
  1188.      * @param x Number.
  1189.      * @return ulp(x).
  1190.      *
  1191.      * @see Math#ulp(double)
  1192.      */
  1193.     public static double ulp(double x) {
  1194.         return ULP_DOUBLE.applyAsDouble(x);
  1195.     }

  1197.     /**
  1198.      * @param x Number.
  1199.      * @return ulp(x).
  1200.      *
  1201.      * @see Math#ulp(float)
  1202.      */
  1203.     public static float ulp(float x) {
  1204.         return ULP_FLOAT.applyAsFloat(x);
  1205.     }

  1207.     /** Interface missing from "java.util.function" package. */
  1208.     private interface FloatUnaryOperator {
  1209.         /**
  1210.          * @param x Operand.
  1211.          * @return the result of applying this operator.
  1212.          */
  1213.         float applyAsFloat(float x);
  1214.     }

  1216.     /** Interface missing from "java.util.function" package. */
  1217.     private interface FloatBinaryOperator {
  1218.         /**
  1219.          * @param x Operand.
  1220.          * @param y Operand.
  1221.          * @return the result of applying this operator.
  1222.          */
  1223.         float applyAsFloat(float x, float y);
  1224.     }

  1226.     /** Interface missing from "java.util.function" package. */
  1227.     private interface FloatDouble2FloatOperator {
  1228.         /**
  1229.          * @param x Operand.
  1230.          * @param y Operand.
  1231.          * @return the result of applying this operator.
  1232.          */
  1233.         float applyAsFloat(float x, double y);
  1234.     }

  1236.     /** Interface missing from "java.util.function" package. */
  1237.     private interface FloatToIntFunction {
  1238.         /**
  1239.          * @param x Operand.
  1240.          * @return the result of applying this operator.
  1241.          */
  1242.         int applyAsInt(float x);
  1243.     }

  1245.     /** Interface missing from "java.util.function" package. */
  1246.     private interface FloatInt2FloatOperator {
  1247.         /**
  1248.          * @param x Operand.
  1249.          * @param y Operand.
  1250.          * @return the result of applying this operator.
  1251.          */
  1252.         float applyAsFloat(float x, int y);
  1253.     }

  1255.     /** Interface missing from "java.util.function" package. */
  1256.     private interface DoubleInt2DoubleOperator {
  1257.         /**
  1258.          * @param x Operand.
  1259.          * @param y Operand.
  1260.          * @return the result of applying this operator.
  1261.          */
  1262.         double applyAsDouble(double x, int y);
  1263.     }
  1264. }
Created with JaCoCo 0.8.10.202304240956Code Coverage Report for Apache Commons Math 4.0-SNAPSHOT