/*
    * 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.numbers.complex;
  
  import org.apache.commons.rng.UniformRandomProvider;
  import org.apache.commons.rng.simple.RandomSource;
  import org.junit.jupiter.api.Assertions;
  import org.junit.jupiter.api.Test;
  
  import java.math.BigDecimal;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.function.BiFunction;
  import java.util.function.Predicate;
  import java.util.function.ToDoubleFunction;
  import java.util.function.UnaryOperator;
  
  /**
   * Tests the standards defined by the C.99 standard for complex numbers
   * defined in ISO/IEC 9899, Annex G.
   *
   * @see <a href="http://www.open-std.org/JTC1/SC22/WG14/www/standards">
   *    ISO/IEC 9899 - Programming languages - C</a>
   */
  class CStandardTest {
  
      private static final double inf = Double.POSITIVE_INFINITY;
      private static final double negInf = Double.NEGATIVE_INFINITY;
      private static final double nan = Double.NaN;
      private static final double max = Double.MAX_VALUE;
      private static final double piOverFour = Math.PI / 4.0;
      private static final double piOverTwo = Math.PI / 2.0;
      private static final double threePiOverFour = 3.0 * Math.PI / 4.0;
      private static final Complex oneZero = complex(1, 0);
      private static final Complex zeroInf = complex(0, inf);
      private static final Complex zeroNegInf = complex(0, negInf);
      private static final Complex zeroNaN = complex(0, nan);
      private static final Complex zeroPiTwo = complex(0.0, piOverTwo);
      private static final Complex negZeroZero = complex(-0.0, 0);
      private static final Complex negZeroNaN = complex(-0.0, nan);
      private static final Complex infZero = complex(inf, 0);
      private static final Complex infNaN = complex(inf, nan);
      private static final Complex infInf = complex(inf, inf);
      private static final Complex infPiTwo = complex(inf, piOverTwo);
      private static final Complex infThreePiFour = complex(inf, threePiOverFour);
      private static final Complex infPiFour = complex(inf, piOverFour);
      private static final Complex infPi = complex(inf, Math.PI);
      private static final Complex negInfInf = complex(negInf, inf);
      private static final Complex negInfZero = complex(negInf, 0);
      private static final Complex negInfNaN = complex(negInf, nan);
      private static final Complex negInfPi = complex(negInf, Math.PI);
      private static final Complex nanInf = complex(nan, inf);
      private static final Complex nanNegInf = complex(nan, negInf);
      private static final Complex nanZero = complex(nan, 0);
      private static final Complex nanPiTwo = complex(nan, piOverTwo);
      private static final Complex piTwoNaN = complex(piOverTwo, nan);
      private static final Complex piNegInf = complex(Math.PI, negInf);
      private static final Complex piTwoNegInf = complex(piOverTwo, negInf);
      private static final Complex piTwoNegZero = complex(piOverTwo, -0.0);
      private static final Complex threePiFourNegInf = complex(threePiOverFour, negInf);
      private static final Complex piFourNegInf = complex(piOverFour, negInf);
      private static final Complex NAN = complex(nan, nan);
      private static final Complex maxMax = complex(max, max);
      private static final Complex maxNan = complex(max, nan);
      private static final Complex nanMax = complex(nan, max);
  
      /** Finite numbers (positive and negative with zero). */
      private static final double[] finite;
      /** Positive finite numbers (with zero). */
      private static final double[] positiveFinite;
      /** Non-zero finite numbers (positive and negative). */
      private static final double[] nonZeroFinite;
      /** Non-zero positive finite numbers. */
      private static final double[] nonZeroPositiveFinite;
      /** Non-zero finite and infinite numbers (positive and negative). */
      private static final double[] nonZero;
  
      static {
          // Choose a range that covers 2 * Math.PI.
          // This is important for the functions that use cis(y).
          final int size = 13;
          finite = new double[size * 2];
          positiveFinite = new double[size];
          for (int i = 0; i < size; i++) {
             final double v = i * 0.5;
             finite[i * 2] = -v;
             finite[i * 2 + 1] = v;
             positiveFinite[i] = v;
         }
 
         // Copy without zero
         nonZeroFinite = Arrays.copyOfRange(finite, 2, finite.length);
         nonZeroPositiveFinite = Arrays.copyOfRange(positiveFinite, 1, positiveFinite.length);
 
         nonZero = Arrays.copyOf(nonZeroFinite, nonZeroFinite.length + 2);
         nonZero[nonZeroFinite.length] = Double.POSITIVE_INFINITY;
         nonZero[nonZeroFinite.length + 1] = Double.NEGATIVE_INFINITY;
 
         // Arrange numerically
         Arrays.sort(finite);
         Arrays.sort(nonZeroFinite);
         Arrays.sort(nonZero);
     }
 
     /**
      * The function type (e.g. odd or even).
      */
     private enum FunctionType {
         /** Odd: f(z) = -f(-z). */
         ODD,
         /** Even: f(z) = f(-z). */
         EVEN,
         /** Not Odd or Even. */
         NONE;
     }
 
     /**
      * An enum containing functionality to remove the sign from complex parts.
      */
     private enum UnspecifiedSign {
         /** Remove the sign from the real component. */
         REAL {
             @Override
             Complex removeSign(Complex c) {
                 return negative(c.getReal()) ? complex(-c.getReal(), c.getImaginary()) : c;
             }
         },
         /** Remove the sign from the imaginary component. */
         IMAGINARY {
             @Override
             Complex removeSign(Complex c) {
                 return negative(c.getImaginary()) ? complex(c.getReal(), -c.getImaginary()) : c;
             }
         },
         /** Remove the sign from the real and imaginary component. */
         REAL_IMAGINARY {
             @Override
             Complex removeSign(Complex c) {
                 return IMAGINARY.removeSign(REAL.removeSign(c));
             }
         },
         /** Do not remove the sign. */
         NONE {
             @Override
             Complex removeSign(Complex c) {
                 return c;
             }
         };
 
         /**
          * Removes the sign from the complex real and or imaginary parts.
          *
          * @param c the complex
          * @return the complex
          */
         abstract Complex removeSign(Complex c);
 
         /**
          * Check that a value is negative. It must meet all the following conditions:
          * <ul>
          *  <li>it is not {@code NaN},</li>
          *  <li>it is negative signed,</li>
          * </ul>
          *
          * <p>Note: This is true for negative zero.</p>
          *
          * @param d Value.
          * @return {@code true} if {@code d} is negative.
          */
         private static boolean negative(double d) {
             return d < 0 || Double.doubleToLongBits(d) == Double.doubleToLongBits(-0.0);
         }
     }
 
     /**
      * Assert the two complex numbers have equivalent real and imaginary components as
      * defined by the {@code ==} operator.
      *
      * @param c1 the first complex (actual)
      * @param c2 the second complex (expected)
      */
     private static void assertComplex(Complex c1, Complex c2) {
         // Use a delta of zero to allow comparison of -0.0 to 0.0
         Assertions.assertEquals(c2.getReal(), c1.getReal(), 0.0, "real");
         Assertions.assertEquals(c2.getImaginary(), c1.getImaginary(), 0.0, "imaginary");
     }
 
     /**
      * Assert the operation on the two complex numbers.
      *
      * @param c1 the first complex
      * @param c2 the second complex
      * @param operation the operation
      * @param operationName the operation name
      * @param expected the expected
      * @param expectedName the expected name
      */
     private static void assertOperation(Complex c1, Complex c2,
             BiFunction<Complex, Complex, Complex> operation, String operationName,
             Predicate<Complex> expected, String expectedName) {
         final Complex z = operation.apply(c1, c2);
         Assertions.assertTrue(expected.test(z),
             () -> String.format("%s expected: %s %s %s = %s", expectedName, c1, operationName, c2, z));
     }
 
     /**
      * Assert the operation on the complex number satisfies the conjugate equality.
      *
      * <pre>
      * op(conj(z)) = conj(op(z))
      * </pre>
      *
      * <p>The results must be binary equal. This includes the sign of zero.
      *
      * <h2>ISO C99 equalities</h2>
      *
      * <p>Note that this method currently enforces the conjugate equalities for some cases
      * where the sign of the real/imaginary parts are unspecified in ISO C99. This is
      * allowed (since they are unspecified). The sign specification is appropriately
      * handled during testing of odd/even functions. There are some functions where it
      * is not possible to satisfy the conjugate equality and also the odd/even rule.
      * The compromise made here is to satisfy only one and the other is allowed to fail
      * only on the sign of the output result. Known functions where this applies are:
      *
      * <ul>
      *  <li>asinh(NaN, inf)
      *  <li>atanh(NaN, inf)
      *  <li>cosh(NaN, 0.0)
      *  <li>sinh(inf, inf)
      *  <li>sinh(inf, nan)
      * </ul>
      *
      * @param operation the operation
      */
     private static void assertConjugateEquality(UnaryOperator<Complex> operation) {
         // Edge cases. Inf/NaN are specifically handled in the C99 test cases
         // but are repeated here to enforce the conjugate equality even when the C99
         // standard does not specify a sign. This may be revised in the future.
         final double[] parts = {Double.NEGATIVE_INFINITY, -1, -0.0, 0.0, 1,
                                 Double.POSITIVE_INFINITY, Double.NaN};
         for (final double x : parts) {
             for (final double y : parts) {
                 // No conjugate for imaginary NaN
                 if (!Double.isNaN(y)) {
                     assertConjugateEquality(complex(x, y), operation, UnspecifiedSign.NONE);
                 }
             }
         }
         // Random numbers
         final UniformRandomProvider rng = RandomSource.SPLIT_MIX_64.create();
         for (int i = 0; i < 100; i++) {
             final double x = next(rng);
             final double y = next(rng);
             assertConjugateEquality(complex(x, y), operation, UnspecifiedSign.NONE);
         }
     }
 
     /**
      * Assert the operation on the complex number satisfies the conjugate equality.
      *
      * <pre>
      * op(conj(z)) = conj(op(z))
      * </pre>
      *
      * <p>The results must be binary equal; the sign of the complex number is first processed
      * using the provided sign specification.
      *
      * @param z the complex number
      * @param operation the operation
      * @param sign the sign specification
      */
     private static void assertConjugateEquality(Complex z,
             UnaryOperator<Complex> operation, UnspecifiedSign sign) {
         final Complex c1 = operation.apply(z.conj());
         final Complex c2 = operation.apply(z).conj();
         final Complex t1 = sign.removeSign(c1);
         final Complex t2 = sign.removeSign(c2);
 
         // Test for binary equality
         if (!equals(t1.getReal(), t2.getReal()) ||
             !equals(t1.getImaginary(), t2.getImaginary())) {
             Assertions.fail(
                 String.format("Conjugate equality failed (z=%s). Expected: %s but was: %s (Unspecified sign = %s)",
                               z, c1, c2, sign));
         }
     }
 
     /**
      * Assert the operation on the complex number is odd or even.
      *
      * <pre>
      * Odd : f(z) = -f(-z)
      * Even: f(z) =  f(-z)
      * </pre>
      *
      * <p>The results must be binary equal. This includes the sign of zero.
      *
      * @param operation the operation
      * @param type the type
      */
     private static void assertFunctionType(UnaryOperator<Complex> operation, FunctionType type) {
         // Note: It may not be possible to satisfy the conjugate equality
         // and be an odd/even function with regard to zero.
         // The C99 standard allows for these cases to have unspecified sign.
         // This test ignores parts that can result in unspecified signed results.
         // The valid edge cases should be tested for each function separately.
         if (type == FunctionType.NONE) {
             return;
         }
 
         // Edge cases around zero.
         final double[] parts = {-2, -1, -0.0, 0.0, 1, 2};
         for (final double x : parts) {
             for (final double y : parts) {
                 assertFunctionType(complex(x, y), operation, type, UnspecifiedSign.NONE);
             }
         }
         // Random numbers
         final UniformRandomProvider rng = RandomSource.SPLIT_MIX_64.create();
         for (int i = 0; i < 100; i++) {
             final double x = next(rng);
             final double y = next(rng);
             assertFunctionType(complex(x, y), operation, type, UnspecifiedSign.NONE);
         }
     }
 
     /**
      * Assert the operation on the complex number is odd or even.
      *
      * <pre>
      * Odd : f(z) = -f(-z)
      * Even: f(z) =  f(-z)
      * </pre>
      *
      * <p>The results must be binary equal; the sign of the complex number is first processed
      * using the provided sign specification.
      *
      * @param z the complex number
      * @param operation the operation
      * @param type the type (assumed to be ODD/EVEN)
      * @param sign the sign specification
      */
     private static void assertFunctionType(Complex z,
             UnaryOperator<Complex> operation, FunctionType type, UnspecifiedSign sign) {
         final Complex c1 = operation.apply(z);
         Complex c2 = operation.apply(z.negate());
         if (type == FunctionType.ODD) {
             c2 = c2.negate();
         }
         final Complex t1 = sign.removeSign(c1);
         final Complex t2 = sign.removeSign(c2);
 
         // Test for binary equality
         if (!equals(t1.getReal(), t2.getReal()) ||
             !equals(t1.getImaginary(), t2.getImaginary())) {
             Assertions.fail(
                 String.format("%s equality failed (z=%s, -z=%s). Expected: %s but was: %s (Unspecified sign = %s)",
                               type, z, z.negate(), c1, c2, sign));
             new Exception().printStackTrace();
         }
     }
 
     /**
      * Assert the operation on the complex number is equal to the expected value.
      * If the imaginary part is not NaN the operation must also satisfy the conjugate equality.
      *
      * <pre>
      * op(conj(z)) = conj(op(z))
      * </pre>
      *
      * <p>The results must be binary equal. This includes the sign of zero.
      *
      * @param z the complex
      * @param operation the operation
      * @param expected the expected
      */
     private static void assertComplex(Complex z,
             UnaryOperator<Complex> operation, Complex expected) {
         assertComplex(z, operation, expected, FunctionType.NONE, UnspecifiedSign.NONE);
     }
 
     /**
      * Assert the operation on the complex number is equal to the expected value. If the
      * imaginary part is not NaN the operation must also satisfy the conjugate equality.
      *
      * <pre>
      * op(conj(z)) = conj(op(z))
      * </pre>
      *
      * <p>The results must be binary equal. This includes the sign of zero.
      *
      * @param z the complex
      * @param operation the operation
      * @param expected the expected
      * @param sign the sign specification
      */
     private static void assertComplex(Complex z,
             UnaryOperator<Complex> operation, Complex expected, UnspecifiedSign sign) {
         assertComplex(z, operation, expected, FunctionType.NONE, sign);
     }
 
     /**
      * Assert the operation on the complex number is equal to the expected value. If the
      * imaginary part is not NaN the operation must also satisfy the conjugate equality.
      *
      * <pre>
      * op(conj(z)) = conj(op(z))
      * </pre>
      *
      * <p>If the function type is ODD/EVEN the operation must satisfy the function type equality.
      *
      * <pre>
      * Odd : f(z) = -f(-z)
      * Even: f(z) =  f(-z)
      * </pre>
      *
      * <p>The results must be binary equal. This includes the sign of zero.
      *
      * @param z the complex
      * @param operation the operation
      * @param expected the expected
      * @param type the type
      */
     private static void assertComplex(Complex z,
             UnaryOperator<Complex> operation, Complex expected,
             FunctionType type) {
         assertComplex(z, operation, expected, type, UnspecifiedSign.NONE);
     }
 
     /**
      * Assert the operation on the complex number is equal to the expected value. If the
      * imaginary part is not NaN the operation must also satisfy the conjugate equality.
      *
      * <pre>
      * op(conj(z)) = conj(op(z))
      * </pre>
      *
      * <p>If the function type is ODD/EVEN the operation must satisfy the function type equality.
      *
      * <pre>
      * Odd : f(z) = -f(-z)
      * Even: f(z) =  f(-z)
      * </pre>
      *
      * <p>An ODD/EVEN function is also tested that the conjugate equalities hold with {@code -z}.
      * This effectively enumerates testing: (re, im); (re, -im); (-re, -im); and (-re, im).
      *
      * <p>The results must be binary equal; the sign of the complex number is first processed
      * using the provided sign specification.
      *
      * @param z the complex
      * @param operation the operation
      * @param expected the expected
      * @param type the type
      * @param sign the sign specification
      */
     private static void assertComplex(Complex z,
             UnaryOperator<Complex> operation, Complex expected,
             FunctionType type, UnspecifiedSign sign) {
         // Developer note: Set the sign specification to UnspecifiedSign.NONE
         // to see which equalities fail. They should be for input defined
         // in ISO C99 with an unspecified output sign, e.g.
         // sign = UnspecifiedSign.NONE
 
         // Test the operation
         final Complex c = operation.apply(z);
         final Complex t1 = sign.removeSign(c);
         final Complex t2 = sign.removeSign(expected);
         if (!equals(t1.getReal(), t2.getReal()) ||
             !equals(t1.getImaginary(), t2.getImaginary())) {
             Assertions.fail(
                 String.format("Operation failed (z=%s). Expected: %s but was: %s (Unspecified sign = %s)",
                               z, expected, c, sign));
         }
 
         if (!Double.isNaN(z.getImaginary())) {
             assertConjugateEquality(z, operation, sign);
         }
 
         if (type != FunctionType.NONE) {
             assertFunctionType(z, operation, type, sign);
 
             // An odd/even function should satisfy the conjugate equality
             // on the negated complex. This ensures testing the equalities
             // hold for:
             // (re, im) =  (re, -im)
             // (re, im) =  (-re, -im) (even)
             //          = -(-re, -im) (odd)
             // (-re, -im) = (-re, im)
             if (!Double.isNaN(z.getImaginary())) {
                 assertConjugateEquality(z.negate(), operation, sign);
             }
         }
     }
 
     /**
      * Assert {@link Complex#abs()} is functionally equivalent to using
      * {@link Math#hypot(double, double)}. If the results differ the true result
      * is computed with extended precision. The test fails if the result is further
      * than the provided ULPs from the reference result.
      *
      * <p>This can be used to assert that the custom implementation of abs() is no worse than
      * {@link Math#hypot(double, double)} which aims to be within 1 ULP of the exact result.
      *
      * <p>Note: This method will not handle an input complex that is infinite or nan so should
      * not be used for edge case tests.
      *
      * <p>Note: The true result is the sum {@code x^2 + y^2} computed using BigDecimal,
      * converted to a double and the sqrt computed using standard precision.
      * This is not the exact result as the BigDecimal
      * sqrt() function was added in Java 9 and is unavailable for the current build target.
      * In this case we require a measure of how close you can get to the nearest-double
      * representing the answer, and the not the exact distance from the answer, so this
      * is valid assuming {@link Math#sqrt(double)} has no error. The test then becomes a
      * measure of the accuracy of the high-precision sum {@code x^2 + y^2}.
      *
      * @param z the complex
      * @param ulps the maximum allowed ULPs from the exact result
      */
     private static void assertAbs(Complex z, int ulps) {
         double x = z.getReal();
         double y = z.getImaginary();
         // For speed use Math.hypot as the reference, not BigDecimal computation.
         final double expected = Math.hypot(x, y);
         final double observed = z.abs();
         if (expected == observed) {
             // This condition will occur in the majority of cases.
             return;
         }
         // Compute the 'exact' result.
         // JDK 9 BigDecimal.sqrt() is not available so compute the standard sqrt of the
         // high precision sum. Do scaling as the high precision sum may not be in the
         // range of a double.
         int scale = 0;
         x = Math.abs(x);
         y = Math.abs(y);
         if (Math.max(x, y) > 0x1.0p+500) {
             scale = Math.getExponent(Math.max(x, y));
         } else if (Math.min(x, y) < 0x1.0p-500) {
             scale = Math.getExponent(Math.min(x, y));
         }
         if (scale != 0) {
             x = Math.scalb(x, -scale);
             y = Math.scalb(y, -scale);
         }
         // Compute and re-scale. 'exact' must be effectively final for use in the
         // assertion message supplier.
         final double result = Math.sqrt(new BigDecimal(x).pow(2).add(new BigDecimal(y).pow(2)).doubleValue());
         final double exact = scale != 0 ? Math.scalb(result, scale) : result;
         if (exact == observed) {
             // Different from Math.hypot but matches the 'exact' result
             return;
         }
         // Distance from the 'exact' result should be within tolerance.
         final long obsBits = Double.doubleToLongBits(observed);
         final long exactBits = Double.doubleToLongBits(exact);
         final long obsUlp = Math.abs(exactBits - obsBits);
         Assertions.assertTrue(obsUlp <= ulps, () -> {
             // Compute for Math.hypot for reference.
             final long expBits = Double.doubleToLongBits(expected);
             final long expUlp = Math.abs(exactBits - expBits);
             return String.format("%s.abs(). Expected %s, was %s (%d ulps). hypot %s (%d ulps)",
                 z, exact, observed, obsUlp, expected, expUlp);
         });
     }
 
     /**
      * Assert {@link Complex#abs()} functions as per {@link Math#hypot(double, double)}.
      * The two numbers for {@code z = x + iy} are generated from the two function.
      *
      * <p>The functions should not generate numbers that are infinite or nan.
      *
      * @param rng Source of randomness
      * @param fx Function to generate x
      * @param fy Function to generate y
      * @param samples Number of samples
      */
     private static void assertAbs(UniformRandomProvider rng,
                                   ToDoubleFunction<UniformRandomProvider> fx,
                                   ToDoubleFunction<UniformRandomProvider> fy,
                                   int samples) {
         for (int i = 0; i < samples; i++) {
             double x = fx.applyAsDouble(rng);
             double y = fy.applyAsDouble(rng);
             assertAbs(Complex.ofCartesian(x, y), 1);
         }
     }
 
     /**
      * Creates a sub-normal number with up to 52-bits in the mantissa. The number of bits
      * to drop must be in the range [0, 51].
      *
      * @param rng Source of randomness
      * @param drop The number of mantissa bits to drop.
      * @return the number
      */
     private static double createSubNormalNumber(UniformRandomProvider rng, int drop) {
         return Double.longBitsToDouble(rng.nextLong() >>> (12 + drop));
     }
 
     /**
      * Creates a number in the range {@code [1, 2)} with up to 52-bits in the mantissa.
      * Then modifies the exponent by the given amount.
      *
      * @param rng Source of randomness
      * @param exponent Amount to change the exponent (in range [-1023, 1023])
      * @return the number
      */
     private static double createFixedExponentNumber(UniformRandomProvider rng, int exponent) {
         return Double.longBitsToDouble((rng.nextLong() >>> 12) | ((1023L + exponent) << 52));
     }
 
     /**
      * Returns {@code true} if the values are equal according to semantics of
      * {@link Double#equals(Object)}.
      *
      * @param x Value
      * @param y Value
      * @return {@code Double.valueof(x).equals(Double.valueOf(y))}
      */
     private static boolean equals(double x, double y) {
         return Double.doubleToLongBits(x) == Double.doubleToLongBits(y);
     }
 
     /**
      * Utility to create a Complex.
      *
      * @param real the real
      * @param imaginary the imaginary
      * @return the complex
      */
     private static Complex complex(double real, double imaginary) {
         return Complex.ofCartesian(real, imaginary);
     }
 
     /**
      * Creates a list of Complex infinites.
      *
      * @return the list
      */
     private static ArrayList<Complex> createInfinites() {
         final double[] values = {0, 1, inf, negInf, nan};
         return createCombinations(values, Complex::isInfinite);
     }
 
     /**
      * Creates a list of Complex finites that are not zero.
      *
      * @return the list
      */
     private static ArrayList<Complex> createNonZeroFinites() {
         final double[] values = {-1, -0, 0, 1, Double.MAX_VALUE};
         return createCombinations(values, c -> !CStandardTest.isZero(c));
     }
 
     /**
      * Creates a list of Complex finites that are zero: [0,0], [-0,0], [0,-0], [-0,-0].
      *
      * @return the list
      */
     private static ArrayList<Complex> createZeroFinites() {
         final double[] values = {-0, 0};
         return createCombinations(values, c -> true);
     }
 
     /**
      * Creates a list of Complex NaNs.
      *
      * @return the list
      */
     private static ArrayList<Complex> createNaNs() {
         final double[] values = {0, 1, nan};
         return createCombinations(values, Complex::isNaN);
     }
 
     /**
      * Creates a list of Complex numbers as an all-vs-all combinations that pass the
      * condition.
      *
      * @param values the values
      * @param condition the condition
      * @return the list
      */
     private static ArrayList<Complex> createCombinations(final double[] values, Predicate<Complex> condition) {
         final ArrayList<Complex> list = new ArrayList<>();
         for (final double re : values) {
             for (final double im : values) {
                 final Complex z = complex(re, im);
                 if (condition.test(z)) {
                     list.add(z);
                 }
             }
         }
         return list;
     }
 
     /**
      * Checks if the complex is zero. This method uses the {@code ==} operator and allows
      * equality between signed zeros: {@code -0.0 == 0.0}.
      *
      * @param c the complex
      * @return true if zero
      */
     private static boolean isZero(Complex c) {
         return c.getReal() == 0 && c.getImaginary() == 0;
     }
 
     /**
      * ISO C Standard G.5 (4).
      */
     @Test
     void testMultiply() {
         final ArrayList<Complex> infinites = createInfinites();
         final ArrayList<Complex> nonZeroFinites = createNonZeroFinites();
         final ArrayList<Complex> zeroFinites = createZeroFinites();
 
         // C.99 refers to non-zero finites.
         // Standard multiplication of zero with infinites is not defined.
         Assertions.assertEquals(nan, 0.0 * inf, "0 * inf");
         Assertions.assertEquals(nan, 0.0 * negInf, "0 * -inf");
         Assertions.assertEquals(nan, -0.0 * inf, "-0 * inf");
         Assertions.assertEquals(nan, -0.0 * negInf, "-0 * -inf");
 
         // "if one operand is an infinity and the other operand is a nonzero finite number or an
         // infinity, then the result of the * operator is an infinity;"
         for (final Complex z : infinites) {
             for (final Complex w : infinites) {
                 assertOperation(z, w, Complex::multiply, "*", Complex::isInfinite, "Inf");
                 assertOperation(w, z, Complex::multiply, "*", Complex::isInfinite, "Inf");
             }
             for (final Complex w : nonZeroFinites) {
                 assertOperation(z, w, Complex::multiply, "*", Complex::isInfinite, "Inf");
                 assertOperation(w, z, Complex::multiply, "*", Complex::isInfinite, "Inf");
             }
             // C.99 refers to non-zero finites.
             // Infer that Complex multiplication of zero with infinites is not defined.
             for (final Complex w : zeroFinites) {
                 assertOperation(z, w, Complex::multiply, "*", Complex::isNaN, "NaN");
                 assertOperation(w, z, Complex::multiply, "*", Complex::isNaN, "NaN");
             }
         }
 
         // ISO C Standard in Annex G is missing an explicit definition of how to handle NaNs.
         // We will assume multiplication by (nan,nan) is not allowed.
         // It is undefined how to multiply when a complex has only one NaN component.
         // The reference implementation in Annex G allows it.
 
         // The GNU g++ compiler computes:
         // (1e300 + i 1e300) * (1e30 + i NAN) = inf + i inf
         // Thus this is allowing some computations with NaN.
 
         // Check multiply with (NaN,NaN) is not corrected
         final double[] values = {0, 1, inf, negInf, nan};
         for (final Complex z : createCombinations(values, c -> true)) {
             assertOperation(z, NAN, Complex::multiply, "*", Complex::isNaN, "NaN");
             assertOperation(NAN, z, Complex::multiply, "*", Complex::isNaN, "NaN");
         }
 
         // Test multiply cases which result in overflow are corrected to infinity
         assertOperation(maxMax, maxMax, Complex::multiply, "*", Complex::isInfinite, "Inf");
         assertOperation(maxNan, maxNan, Complex::multiply, "*", Complex::isInfinite, "Inf");
         assertOperation(nanMax, maxNan, Complex::multiply, "*", Complex::isInfinite, "Inf");
         assertOperation(maxNan, nanMax, Complex::multiply, "*", Complex::isInfinite, "Inf");
         assertOperation(nanMax, nanMax, Complex::multiply, "*", Complex::isInfinite, "Inf");
     }
 
     /**
      * ISO C Standard G.5 (4).
      */
     @Test
     void testDivide() {
         final ArrayList<Complex> infinites = createInfinites();
         final ArrayList<Complex> nonZeroFinites = createNonZeroFinites();
         final ArrayList<Complex> zeroFinites = createZeroFinites();
         final ArrayList<Complex> nans = createNaNs();
         final ArrayList<Complex> finites = new ArrayList<>(nonZeroFinites);
         finites.addAll(zeroFinites);
 
         // "if the first operand is an infinity and the second operand is a finite number, then the
         // result of the / operator is an infinity;"
         for (final Complex z : infinites) {
             for (final Complex w : nonZeroFinites) {
                 assertOperation(z, w, Complex::divide, "/", Complex::isInfinite, "Inf");
             }
             for (final Complex w : zeroFinites) {
                 assertOperation(z, w, Complex::divide, "/", Complex::isInfinite, "Inf");
             }
             // Check inf/inf cannot be done
             for (final Complex w : infinites) {
                 assertOperation(z, w, Complex::divide, "/", Complex::isNaN, "NaN");
             }
         }
 
         // "if the first operand is a finite number and the second operand is an infinity, then the
         // result of the / operator is a zero;"
         for (final Complex z : finites) {
             for (final Complex w : infinites) {
                 assertOperation(z, w, Complex::divide, "/", CStandardTest::isZero, "Zero");
             }
         }
 
         // "if the first operand is a nonzero finite number or an infinity and the second operand is
         // a zero, then the result of the / operator is an infinity."
         for (final Complex w : zeroFinites) {
             for (final Complex z : nonZeroFinites) {
                 assertOperation(z, w, Complex::divide, "/", Complex::isInfinite, "Inf");
             }
             for (final Complex z : infinites) {
                 assertOperation(z, w, Complex::divide, "/", Complex::isInfinite, "Inf");
             }
         }
 
         // ISO C Standard in Annex G is missing an explicit definition of how to handle NaNs.
         // The reference implementation does not correct for divide by NaN components unless
         // infinite.
         for (final Complex w : nans) {
             for (final Complex z : finites) {
                 assertOperation(z, w, Complex::divide, "/", c -> NAN.equals(c), "(NaN,NaN)");
             }
             for (final Complex z : infinites) {
                 assertOperation(z, w, Complex::divide, "/", c -> NAN.equals(c), "(NaN,NaN)");
             }
         }
 
         // Check (NaN,NaN) divide is not corrected for the edge case of divide by zero or infinite
         for (final Complex w : zeroFinites) {
             assertOperation(NAN, w, Complex::divide, "/", Complex::isNaN, "NaN");
         }
         for (final Complex w : infinites) {
             assertOperation(NAN, w, Complex::divide, "/", Complex::isNaN, "NaN");
         }
     }
 
     /**
      * ISO C Standard G.6 (3).
      */
     @Test
     void testSqrt1() {
         assertComplex(complex(-2.0, 0.0).sqrt(), complex(0.0, Math.sqrt(2)));
         assertComplex(complex(-2.0, -0.0).sqrt(), complex(0.0, -Math.sqrt(2)));
     }
 
     /**
      * ISO C Standard G.6 (7).
      */
     @Test
     void testImplicitTrig() {
         final UniformRandomProvider rng = RandomSource.SPLIT_MIX_64.create();
         for (int i = 0; i < 100; i++) {
             final double re = next(rng);
             final double im = next(rng);
             final Complex z = complex(re, im);
             final Complex iz = z.multiplyImaginary(1);
             assertComplex(z.asin(), iz.asinh().multiplyImaginary(-1));
             assertComplex(z.atan(), iz.atanh().multiplyImaginary(-1));
             assertComplex(z.cos(), iz.cosh());
             assertComplex(z.sin(), iz.sinh().multiplyImaginary(-1));
             assertComplex(z.tan(), iz.tanh().multiplyImaginary(-1));
         }
     }
 
     /**
      * Create a number in the range {@code [-5,5)}.
      *
      * @param rng the random generator
      * @return the number
      */
     private static double next(UniformRandomProvider rng) {
         // Note: [0, 1) minus 1 is [-1, 0). This occurs half the time to create [-1, 1).
         return (rng.nextDouble() - rng.nextInt(1)) * 5;
     }
 
     /**
      * ISO C Standard G.6 (6) for abs().
      * Functionality is defined by ISO C Standard F.9.4.3 hypot function.
      */
     @Test
     void testAbs() {
         Assertions.assertEquals(inf, complex(inf, nan).abs());
         Assertions.assertEquals(inf, complex(negInf, nan).abs());
         final UniformRandomProvider rng = RandomSource.XO_RO_SHI_RO_128_PP.create();
         for (int i = 0; i < 10; i++) {
             final double x = next(rng);
             final double y = next(rng);
             Assertions.assertEquals(complex(x, y).abs(), complex(y, x).abs());
             Assertions.assertEquals(complex(x, y).abs(), complex(x, -y).abs());
             Assertions.assertEquals(Math.abs(x), complex(x, 0.0).abs());
             Assertions.assertEquals(Math.abs(x), complex(x, -0.0).abs());
             Assertions.assertEquals(inf, complex(inf, y).abs());
             Assertions.assertEquals(inf, complex(negInf, y).abs());
         }
 
         // Test verses Math.hypot due to the use of a custom implementation.
         // First test edge cases. Use negatives to test the sign is correctly removed.
         final double[] parts = {-0.0, -Double.MIN_VALUE, -Double.MIN_NORMAL, -Double.MAX_VALUE,
             Double.NEGATIVE_INFINITY, Double.NaN};
         for (final double x : parts) {
             for (final double y : parts) {
                 Assertions.assertEquals(Math.hypot(x, y), complex(x, y).abs());
             }
         }
 
         // The reference fdlibm hypot implementation orders using the upper 32-bits of the double.
         // Tests using random numbers that differ in only the lower 32-bits
         // show a frequency of <1e-9 that the computation is not commutative: f(x, y) != f(y, x)
         // Test known cases where ordering is required on the lower 32-bits to ensure |z| == |iz|.
         // These cases would fail a direct fdlibm conversion of this:
         // https://www.netlib.org/fdlibm/e_hypot.c
         for (final double[] pair : new double[][] {
                 {1.3122561682406755, 1.3122565442732959},
                 {1.40905821964671, 1.4090583434236112},
                 {1.912164268932753, 1.9121638616231227}}) {
             final Complex z = complex(pair[0], pair[1]);
             Assertions.assertEquals(z.abs(), z.multiplyImaginary(1).abs(), "Expected |z| == |iz|");
         }
 
         // Test with a range of numbers.
         // Sub-normals require special handling so we use different variations of these to
         // ensure they are handled correctly.
         // Note:
         // 1 ULP differences with Math.hypot can be observed due to the different implementations.
         // For normal numbers observable differences require billions of numbers to show a
         // few hundred cases of lower ULPs and a magnitude smaller count of higher ULPs.
         // For sub-normal numbers a few thousand examples can demonstrate
         // a larger count of 1 ULP improvements than 1 ULP errors verses Math.hypot.
         // A formal statistical test to demonstrate differences are significant is not implemented.
         // This test simply asserts the answer is either the same as Math.hypot or else is within
         // 1 ULP of a high precision computation.
         final int samples = 100;
         assertAbs(rng, r -> createSubNormalNumber(r, 0), r -> createSubNormalNumber(r, 0), samples);
         assertAbs(rng, r -> createSubNormalNumber(r, 0), r -> createSubNormalNumber(r, 1), samples);
         assertAbs(rng, r -> createSubNormalNumber(r, 0), r -> createSubNormalNumber(r, 2), samples);
         // Numbers on the same scale (fixed exponent)
         assertAbs(rng, r -> createFixedExponentNumber(r, 0), r -> createFixedExponentNumber(r, 0), samples);
         // Numbers on different scales
         assertAbs(rng, r -> createFixedExponentNumber(r, 0), r -> createFixedExponentNumber(r, 1), samples);
         assertAbs(rng, r -> createFixedExponentNumber(r, 0), r -> createFixedExponentNumber(r, 2 + r.nextInt(10)), samples);
         // Intermediate overflow / underflow
         assertAbs(rng, r -> createFixedExponentNumber(r, 1022), r -> createFixedExponentNumber(r, 1022), samples);
         assertAbs(rng, r -> createFixedExponentNumber(r, -1022), r -> createFixedExponentNumber(r, -1022), samples);
         // Complex cis numbers
         final ToDoubleFunction<UniformRandomProvider> cisGenerator = new ToDoubleFunction<UniformRandomProvider>() {
             private double tmp = Double.NaN;
             @Override
             public double applyAsDouble(UniformRandomProvider rng) {
                 if (Double.isNaN(tmp)) {
                     double u = rng.nextDouble() * Math.PI;
                     tmp = Math.cos(u);
                     return Math.sin(u);
                 }
                 final double r = tmp;
                 tmp = Double.NaN;
                 return r;
             }
         };
         assertAbs(rng, cisGenerator, cisGenerator, samples);
     }
 
     /**
      * ISO C Standard G.6.1.1.
      */
     @Test
     void testAcos() {
         final UnaryOperator<Complex> operation = Complex::acos;
         assertConjugateEquality(operation);
         assertComplex(Complex.ZERO, operation, piTwoNegZero);
         assertComplex(negZeroZero, operation, piTwoNegZero);
         assertComplex(zeroNaN, operation, piTwoNaN);
         assertComplex(negZeroNaN, operation, piTwoNaN);
         for (double x : finite) {
             assertComplex(complex(x, inf), operation, piTwoNegInf);
         }
         for (double x : nonZeroFinite) {
             assertComplex(complex(x, nan), operation, NAN);
         }
         for (double y : positiveFinite) {
             assertComplex(complex(-inf, y), operation, piNegInf);
         }
         for (double y : positiveFinite) {
             assertComplex(complex(inf, y), operation, zeroNegInf);
         }
         assertComplex(negInfInf, operation, threePiFourNegInf);
         assertComplex(infInf, operation, piFourNegInf);
         assertComplex(infNaN, operation, nanInf, UnspecifiedSign.IMAGINARY);
         assertComplex(negInfNaN, operation, nanNegInf, UnspecifiedSign.IMAGINARY);
         for (double y : finite) {
             assertComplex(complex(nan, y), operation, NAN);
         }
         assertComplex(nanInf, operation, nanNegInf);
         assertComplex(NAN, operation, NAN);
     }
 
     /**
      * ISO C Standard G.6.2.1.
      *
      * @see <a href="http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1892.htm#dr_471">
      *   Complex math functions cacosh and ctanh</a>
      */
     @Test
     void testAcosh() {
         final UnaryOperator<Complex> operation = Complex::acosh;
         assertConjugateEquality(operation);
         assertComplex(Complex.ZERO, operation, zeroPiTwo);
         assertComplex(negZeroZero, operation, zeroPiTwo);
         for (double x : finite) {
             assertComplex(complex(x, inf), operation, infPiTwo);
         }
         assertComplex(zeroNaN, operation, nanPiTwo);
         assertComplex(negZeroNaN, operation, nanPiTwo);
         for (double x : nonZeroFinite) {
             assertComplex(complex(x, nan), operation, NAN);
         }
         for (double y : positiveFinite) {
             assertComplex(complex(-inf, y), operation, infPi);
         }
         for (double y : positiveFinite) {
             assertComplex(complex(inf, y), operation, infZero);
         }
         assertComplex(negInfInf, operation, infThreePiFour);
         assertComplex(infInf, operation, infPiFour);
         assertComplex(infNaN, operation, infNaN);
         assertComplex(negInfNaN, operation, infNaN);
         for (double y : finite) {
             assertComplex(complex(nan, y), operation, NAN);
         }
         assertComplex(nanInf, operation, infNaN);
         assertComplex(NAN, operation, NAN);
     }
 
     /**
      * ISO C Standard G.6.2.2.
      */
     @Test
     void testAsinh() {
         final UnaryOperator<Complex> operation = Complex::asinh;
         final FunctionType type = FunctionType.ODD;
         assertConjugateEquality(operation);
         assertFunctionType(operation, type);
         assertComplex(Complex.ZERO, operation, Complex.ZERO, type);
         for (double x : positiveFinite) {
             assertComplex(complex(x, inf), operation, infPiTwo, type);
         }
         for (double x : finite) {
             assertComplex(complex(x, nan), operation, NAN, type);
         }
         for (double y : positiveFinite) {
             assertComplex(complex(inf, y), operation, infZero, type);
         }
         assertComplex(infInf, operation, infPiFour, type);
         assertComplex(infNaN, operation, infNaN, type);
         assertComplex(nanZero, operation, nanZero, type);
         for (double y : nonZeroFinite) {
             assertComplex(complex(nan, y), operation, NAN, type);
         }
         assertComplex(nanInf, operation, infNaN, type, UnspecifiedSign.REAL);
         assertComplex(NAN, operation, NAN, type);
     }
 
     /**
      * ISO C Standard G.6.2.3.
      */
     @Test
     void testAtanh() {
         final UnaryOperator<Complex> operation = Complex::atanh;
         final FunctionType type = FunctionType.ODD;
         assertConjugateEquality(operation);
         assertFunctionType(operation, type);
         assertComplex(Complex.ZERO, operation, Complex.ZERO, type);
         assertComplex(zeroNaN, operation, zeroNaN, type);
         assertComplex(oneZero, operation, infZero, type);
         for (double x : positiveFinite) {
             assertComplex(complex(x, inf), operation, zeroPiTwo, type);
         }
         for (double x : nonZeroFinite) {
             assertComplex(complex(x, nan), operation, NAN, type);
         }
         for (double y : positiveFinite) {
             assertComplex(complex(inf, y), operation, zeroPiTwo, type);
         }
         assertComplex(infInf, operation, zeroPiTwo, type);
         assertComplex(infNaN, operation, zeroNaN, type);
         assertComplex(nanZero, operation, NAN, type);
         for (double y : finite) {
             assertComplex(complex(nan, y), operation, NAN, type);
         }
         assertComplex(nanInf, operation, zeroPiTwo, type, UnspecifiedSign.REAL);
         assertComplex(NAN, operation, NAN, type);
     }
 
     /**
      * ISO C Standard G.6.2.4.
      */
     @Test
     void testCosh() {
         final UnaryOperator<Complex> operation = Complex::cosh;
         final FunctionType type = FunctionType.EVEN;
         assertConjugateEquality(operation);
         assertFunctionType(operation, type);
         assertComplex(Complex.ZERO, operation, Complex.ONE, type);
         assertComplex(zeroInf, operation, nanZero, type, UnspecifiedSign.IMAGINARY);
         assertComplex(zeroNaN, operation, nanZero, type, UnspecifiedSign.IMAGINARY);
         for (double x : nonZeroFinite) {
             assertComplex(complex(x, inf), operation, NAN, type);
         }
         for (double x : nonZeroFinite) {
             assertComplex(complex(x, nan), operation, NAN, type);
         }
         assertComplex(infZero, operation, infZero, type);
         for (double y : nonZeroFinite) {
             assertComplex(complex(inf, y), operation, Complex.ofCis(y).multiply(inf), type);
         }
         assertComplex(infInf, operation, infNaN, type, UnspecifiedSign.REAL);
         assertComplex(infNaN, operation, infNaN, type);
         assertComplex(nanZero, operation, nanZero, type, UnspecifiedSign.IMAGINARY);
         for (double y : nonZero) {
             assertComplex(complex(nan, y), operation, NAN, type);
         }
         assertComplex(NAN, operation, NAN, type);
     }
 
     /**
      * ISO C Standard G.6.2.5.
      */
     @Test
     void testSinh() {
         final UnaryOperator<Complex> operation = Complex::sinh;
         final FunctionType type = FunctionType.ODD;
         assertConjugateEquality(operation);
         assertFunctionType(operation, type);
         assertComplex(Complex.ZERO, operation, Complex.ZERO, type);
         assertComplex(zeroInf, operation, zeroNaN, type, UnspecifiedSign.REAL);
         assertComplex(zeroNaN, operation, zeroNaN, type, UnspecifiedSign.REAL);
         for (double x : nonZeroPositiveFinite) {
             assertComplex(complex(x, inf), operation, NAN, type);
         }
         for (double x : nonZeroFinite) {
             assertComplex(complex(x, nan), operation, NAN, type);
         }
         assertComplex(infZero, operation, infZero, type);
         // Note: Error in the ISO C99 reference to use positive finite y but the zero case is different
         for (double y : nonZeroFinite) {
             assertComplex(complex(inf, y), operation, Complex.ofCis(y).multiply(inf), type);
         }
         assertComplex(infInf, operation, infNaN, type, UnspecifiedSign.REAL);
         assertComplex(infNaN, operation, infNaN, type, UnspecifiedSign.REAL);
         assertComplex(nanZero, operation, nanZero, type);
         for (double y : nonZero) {
             assertComplex(complex(nan, y), operation, NAN, type);
         }
         assertComplex(NAN, operation, NAN, type);
     }
 
     /**
      * ISO C Standard G.6.2.6.
      *
      * @see <a href="http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1892.htm#dr_471">
      *   Complex math functions cacosh and ctanh</a>
      */
     @Test
     void testTanh() {
         final UnaryOperator<Complex> operation = Complex::tanh;
         final FunctionType type = FunctionType.ODD;
         assertConjugateEquality(operation);
         assertFunctionType(operation, type);
         assertComplex(Complex.ZERO, operation, Complex.ZERO, type);
         assertComplex(zeroInf, operation, zeroNaN, type);
         for (double x : nonZeroFinite) {
             assertComplex(complex(x, inf), operation, NAN, type);
         }
         assertComplex(zeroNaN, operation, zeroNaN, type);
         for (double x : nonZeroFinite) {
             assertComplex(complex(x, nan), operation, NAN, type);
         }
         for (double y : positiveFinite) {
             assertComplex(complex(inf, y), operation, complex(1.0, Math.copySign(0, Math.sin(2 * y))), type);
         }
         assertComplex(infInf, operation, oneZero, type, UnspecifiedSign.IMAGINARY);
         assertComplex(infNaN, operation, oneZero, type, UnspecifiedSign.IMAGINARY);
         assertComplex(nanZero, operation, nanZero, type);
         for (double y : nonZero) {
             assertComplex(complex(nan, y), operation, NAN, type);
         }
         assertComplex(NAN, operation, NAN, type);
     }
 
     /**
      * ISO C Standard G.6.3.1.
      */
     @Test
     void testExp() {
         final UnaryOperator<Complex> operation = Complex::exp;
         assertConjugateEquality(operation);
         assertComplex(Complex.ZERO, operation, oneZero);
         assertComplex(negZeroZero, operation, oneZero);
         for (double x : finite) {
             assertComplex(complex(x, inf), operation, NAN);
         }
         for (double x : finite) {
             assertComplex(complex(x, nan), operation, NAN);
         }
         assertComplex(infZero, operation, infZero);
         for (double y : finite) {
             assertComplex(complex(-inf, y), operation, Complex.ofCis(y).multiply(0.0));
         }
         for (double y : nonZeroFinite) {
             assertComplex(complex(inf, y), operation, Complex.ofCis(y).multiply(inf));
         }
         assertComplex(negInfInf, operation, Complex.ZERO, UnspecifiedSign.REAL_IMAGINARY);
         assertComplex(infInf, operation, infNaN, UnspecifiedSign.REAL);
         assertComplex(negInfNaN, operation, Complex.ZERO, UnspecifiedSign.REAL_IMAGINARY);
         assertComplex(infNaN, operation, infNaN, UnspecifiedSign.REAL);
         assertComplex(nanZero, operation, nanZero);
         for (double y : nonZero) {
             assertComplex(complex(nan, y), operation, NAN);
         }
         assertComplex(NAN, operation, NAN);
     }
 
     /**
      * ISO C Standard G.6.3.2.
      */
     @Test
     void testLog() {
         final UnaryOperator<Complex> operation = Complex::log;
         assertConjugateEquality(operation);
         assertComplex(negZeroZero, operation, negInfPi);
         assertComplex(Complex.ZERO, operation, negInfZero);
         for (double x : finite) {
             assertComplex(complex(x, inf), operation, infPiTwo);
         }
         for (double x : finite) {
             assertComplex(complex(x, nan), operation, NAN);
         }
         for (double y : positiveFinite) {
             assertComplex(complex(-inf, y), operation, infPi);
         }
         for (double y : positiveFinite) {
             assertComplex(complex(inf, y), operation, infZero);
         }
         assertComplex(negInfInf, operation, infThreePiFour);
         assertComplex(infInf, operation, infPiFour);
         assertComplex(negInfNaN, operation, infNaN);
         assertComplex(infNaN, operation, infNaN);
         for (double y : finite) {
             assertComplex(complex(nan, y), operation, NAN);
         }
         assertComplex(nanInf, operation, infNaN);
         assertComplex(NAN, operation, NAN);
     }
 
     /**
      * Same edge cases as log() since the real component is divided by Math.log(10) which
      * has no effect on infinite or nan.
      */
     @Test
     void testLog10() {
         final UnaryOperator<Complex> operation = Complex::log10;
         assertConjugateEquality(operation);
         assertComplex(negZeroZero, operation, negInfPi);
         assertComplex(Complex.ZERO, operation, negInfZero);
         for (double x : finite) {
             assertComplex(complex(x, inf), operation, infPiTwo);
         }
         for (double x : finite) {
             assertComplex(complex(x, nan), operation, NAN);
         }
         for (double y : positiveFinite) {
             assertComplex(complex(-inf, y), operation, infPi);
         }
         for (double y : positiveFinite) {
             assertComplex(complex(inf, y), operation, infZero);
         }
         assertComplex(negInfInf, operation, infThreePiFour);
         assertComplex(infInf, operation, infPiFour);
         assertComplex(negInfNaN, operation, infNaN);
         assertComplex(infNaN, operation, infNaN);
         for (double y : finite) {
             assertComplex(complex(nan, y), operation, NAN);
         }
         assertComplex(nanInf, operation, infNaN);
         assertComplex(NAN, operation, NAN);
     }
 
     /**
      * ISO C Standard G.6.4.2.
      */
     @Test
     void testSqrt() {
         final UnaryOperator<Complex> operation = Complex::sqrt;
         assertConjugateEquality(operation);
         assertComplex(negZeroZero, operation, Complex.ZERO);
         assertComplex(Complex.ZERO, operation, Complex.ZERO);
         for (double x : finite) {
             assertComplex(complex(x, inf), operation, infInf);
         }
         // Include infinity and nan for (x, inf).
         assertComplex(infInf, operation, infInf);
         assertComplex(negInfInf, operation, infInf);
         assertComplex(nanInf, operation, infInf);
         for (double x : finite) {
             assertComplex(complex(x, nan), operation, NAN);
         }
         for (double y : positiveFinite) {
             assertComplex(complex(-inf, y), operation, zeroInf);
         }
         for (double y : positiveFinite) {
             assertComplex(complex(inf, y), operation, infZero);
         }
         assertComplex(negInfNaN, operation, nanInf, UnspecifiedSign.IMAGINARY);
         assertComplex(infNaN, operation, infNaN);
         for (double y : finite) {
             assertComplex(complex(nan, y), operation, NAN);
         }
         assertComplex(NAN, operation, NAN);
     }
 }