commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ericbarnh...@apache.org
Subject commons-numbers git commit: NUMBERS-60: NaN descriptions in javadoc altered to reflect C++ standards. NaN changed to NAN.
Date Mon, 12 Feb 2018 12:14:08 GMT
Repository: commons-numbers
Updated Branches:
  refs/heads/remove-nan-returns [created] 2f1c0b5dc


NUMBERS-60: NaN descriptions in javadoc altered to reflect C++
standards. NaN changed to NAN.

Project: http://git-wip-us.apache.org/repos/asf/commons-numbers/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-numbers/commit/2f1c0b5d
Tree: http://git-wip-us.apache.org/repos/asf/commons-numbers/tree/2f1c0b5d
Diff: http://git-wip-us.apache.org/repos/asf/commons-numbers/diff/2f1c0b5d

Branch: refs/heads/remove-nan-returns
Commit: 2f1c0b5dc250b34c2e7d4a7844c76d67e5ce2b2e
Parents: b077fd5
Author: Eric Barnhill <ericbarnhill@apache.org>
Authored: Mon Feb 12 13:15:12 2018 +0100
Committer: Eric Barnhill <ericbarnhill@apache.org>
Committed: Mon Feb 12 13:15:12 2018 +0100

----------------------------------------------------------------------
 .../apache/commons/numbers/complex/Complex.java | 43 +++++---------
 .../commons/numbers/complex/ComplexUtils.java   |  2 +-
 .../commons/numbers/complex/CStandardTest.java  | 60 ++++++++++----------
 .../commons/numbers/complex/ComplexTest.java    | 22 +++----
 .../numbers/complex/ComplexUtilsTest.java       | 14 ++---
 5 files changed, 63 insertions(+), 78 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/commons-numbers/blob/2f1c0b5d/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/Complex.java
----------------------------------------------------------------------
diff --git a/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/Complex.java
b/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/Complex.java
index f3295c3..d7c9d59 100644
--- a/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/Complex.java
+++ b/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/Complex.java
@@ -49,7 +49,7 @@ public class Complex implements Serializable  {
     public static final Complex I = new Complex(0, 1);
     // CHECKSTYLE: stop ConstantName
     /** A complex number representing "NaN + NaNi" */
-    public static final Complex NaN = new Complex(Double.NaN, Double.NaN);
+    public static final Complex NAN = new Complex(Double.NaN, Double.NaN);
     // CHECKSTYLE: resume ConstantName
     /** A complex number representing "+INF + INFi" */
     public static final Complex INF = new Complex(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
@@ -88,10 +88,7 @@ public class Complex implements Serializable  {
 
      /**
      * Creates a Complex from its polar representation.
-     * <p>
-     * If either {@code r} or {@code theta} is NaN, or {@code theta} is
-     * infinite, {@link Complex#NaN} is returned.
-     * <p>
+     *
      * If {@code r} is infinite and {@code theta} is finite, infinite or NaN
      * values may be returned in parts of the result, following the rules for
      * double arithmetic.
@@ -177,10 +174,9 @@ public class Complex implements Serializable  {
 
      /**
      * Return the absolute value of this complex number.
-     * Returns {@code NaN} if either real or imaginary part is {@code NaN}
-     * and {@code Double.POSITIVE_INFINITY} if neither part is {@code NaN},
-     * but at least one part is infinite.
-     * This code follows the <a href="http://www.iso-9899.info/wiki/The_Standard">ISO
C Standard</a>, Annex G, in calculating the returned value (i.e. the hypot(x,y) method)
+     * This code follows the <a href="http://www.iso-9899.info/wiki/The_Standard">ISO
C Standard</a>, Annex G,
+     * in calculating the returned value (i.e. the hypot(x,y) method)
+     * and in handling of NaNs.
      *
      * @return the absolute value.
      */
@@ -276,10 +272,10 @@ public class Complex implements Serializable  {
      * {@code Infinite} and {@code NaN} values are handled according to the
      * following rules, applied in the order presented:
      * <ul>
-     *  <li>If {@code divisor} equals {@link #ZERO}, {@link #NaN} is returned.
+     *  <li>If {@code divisor} equals {@link #ZERO}, {@link #NAN} is returned.
      *  </li>
      *  <li>If {@code this} and {@code divisor} are both infinite,
-     *   {@link #NaN} is returned.
+     *   {@link #NAN} is returned.
      *  </li>
      *  <li>If {@code this} is finite (i.e., has no {@code Infinite} or
      *   {@code NaN} parts) and {@code divisor} is infinite (one or both parts
@@ -301,7 +297,7 @@ public class Complex implements Serializable  {
         final double d = divisor.imaginary;
         if (c == 0 &&
             d == 0) {
-            return NaN;
+            return NAN;
         }
 
         if ((Double.isInfinite(c) ||
@@ -334,11 +330,11 @@ public class Complex implements Serializable  {
      */
     public Complex divide(double divisor) {
         if (divisor == 0d) {
-            return NaN;
+            return NAN;
         }
         if (Double.isInfinite(divisor)) {
             return !(Double.isInfinite(real) ||
-                     Double.isInfinite(imaginary)) ? ZERO : NaN;
+                     Double.isInfinite(imaginary)) ? ZERO : NAN;
         }
         return new Complex(real / divisor,
                            imaginary  / divisor);
@@ -549,19 +545,10 @@ public class Complex implements Serializable  {
 
     /**
      * Returns a {@code Complex} whose value is {@code this * factor}.
-     * Implements preliminary checks for {@code NaN} and infinity followed by
-     * the definitional formula:
+     * Implements the definitional formula:
      *
      *   {@code (a + bi)(c + di) = (ac - bd) + (ad + bc)i}
      *
-     * Returns {@link #NaN} if either {@code this} or {@code factor} has one or
-     * more {@code NaN} parts.
-     *
-     * Returns {@link #INF} if neither {@code this} nor {@code factor} has one
-     * or more {@code NaN} parts and if either {@code this} or {@code factor}
-     * has one or more infinite parts (same result is returned regardless of
-     * the sign of the components).
-     *
      * Returns finite values in components of the result per the definitional
      * formula in all remaining cases.
      *
@@ -599,8 +586,6 @@ public class Complex implements Serializable  {
 
     /**
      * Returns a {@code Complex} whose value is {@code (-this)}.
-     * Returns {@code NaN} if either real or imaginary
-     * part of this complex number is {@code Double.NaN}.
      *
      * @return {@code -this}.
      */
@@ -965,7 +950,7 @@ public class Complex implements Serializable  {
                 return ZERO;
             } else {
                 // 0 raised to anything else is NaN
-                return NaN;
+                return NAN;
             }
         }
         return log().multiply(x).exp();
@@ -986,7 +971,7 @@ public class Complex implements Serializable  {
                 return ZERO;
             } else {
                 // 0 raised to anything else is NaN
-                return NaN;
+                return NAN;
             }
         }
         return log().multiply(x).exp();
@@ -1226,7 +1211,7 @@ public class Complex implements Serializable  {
      * {@link #getArgument() argument} of this complex number.
      * <p>
      * If one or both parts of this complex number is NaN, a list with just
-     * one element, {@link #NaN} is returned.
+     * one element, {@link #NAN} is returned.
      * if neither part is NaN, but at least one part is infinite, the result
      * is a one-element list containing {@link #INF}.
      *

http://git-wip-us.apache.org/repos/asf/commons-numbers/blob/2f1c0b5d/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/ComplexUtils.java
----------------------------------------------------------------------
diff --git a/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/ComplexUtils.java
b/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/ComplexUtils.java
index 3fdd10f..b9f758a 100644
--- a/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/ComplexUtils.java
+++ b/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/ComplexUtils.java
@@ -31,7 +31,7 @@ public class ComplexUtils {
      * Creates a complex number from the given polar representation.
      * <p>
      * If either {@code r} or {@code theta} is NaN, or {@code theta} is
-     * infinite, {@link Complex#NaN} is returned.
+     * infinite, {@link Complex#NAN} is returned.
      * <p>
      * If {@code r} is infinite and {@code theta} is finite, infinite or NaN
      * values may be returned in parts of the result, following the rules for

http://git-wip-us.apache.org/repos/asf/commons-numbers/blob/2f1c0b5d/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java
----------------------------------------------------------------------
diff --git a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java
b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java
index ed0bf4f..e79ce9f 100644
--- a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java
+++ b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java
@@ -115,16 +115,16 @@ public class CStandardTest {
         assertComplex(negZeroZero.acos(), piTwoNegZero);
         assertComplex(zeroNaN.acos(), piTwoNaN);
         assertComplex(oneInf.acos(), piTwoNegInf);
-        assertComplex(oneNaN.acos(), Complex.NaN);
+        assertComplex(oneNaN.acos(), Complex.NAN);
         assertComplex(negInfOne.acos(), piNegInf);
         assertComplex(infOne.acos(), zeroNegInf);
         assertComplex(negInfPosInf.acos(), threePiFourNegInf);
         assertComplex(infInf.acos(), piFourNegInf);
         assertComplex(infNaN.acos(), nanInf);
         assertComplex(negInfNaN.acos(), nanNegInf);
-        assertComplex(nanOne.acos(), Complex.NaN);
+        assertComplex(nanOne.acos(), Complex.NAN);
         assertComplex(nanInf.acos(), nanNegInf);
-        assertComplex(Complex.NaN.acos(), Complex.NaN);
+        assertComplex(Complex.NAN.acos(), Complex.NAN);
     }
 
     /**
@@ -136,14 +136,14 @@ public class CStandardTest {
         assertComplex(oneOne.conj().asinh(), oneOne.asinh().conj());
         assertComplex(Complex.ZERO.asinh(), Complex.ZERO);
         assertComplex(oneInf.asinh(), infPiTwo);
-        assertComplex(oneNaN.asinh(), Complex.NaN);
+        assertComplex(oneNaN.asinh(), Complex.NAN);
         assertComplex(infOne.asinh(), infZero);
         assertComplex(infInf.asinh(), infPiFour);
         assertComplex(infNaN.asinh(), infNaN);
         assertComplex(nanZero.asinh(), nanZero);
-        assertComplex(nanOne.asinh(), Complex.NaN);
+        assertComplex(nanOne.asinh(), Complex.NAN);
         assertComplex(nanInf.asinh(), infNaN);
-        assertComplex(Complex.NaN, Complex.NaN);
+        assertComplex(Complex.NAN, Complex.NAN);
     }
 
     /**
@@ -156,13 +156,13 @@ public class CStandardTest {
         assertComplex(zeroNaN.atanh(), zeroNaN);
         assertComplex(oneZero.atanh(), infZero);
         assertComplex(oneInf.atanh(),zeroPiTwo);
-        assertComplex(oneNaN.atanh(), Complex.NaN);
+        assertComplex(oneNaN.atanh(), Complex.NAN);
         assertComplex(infOne.atanh(), zeroPiTwo);
         assertComplex(infInf.atanh(), zeroPiTwo);
         assertComplex(infNaN.atanh(), zeroNaN);
-        assertComplex(nanOne.atanh(), Complex.NaN);
+        assertComplex(nanOne.atanh(), Complex.NAN);
         assertComplex(nanInf.atanh(), zeroPiTwo);
-        assertComplex(Complex.NaN.atanh(), Complex.NaN);
+        assertComplex(Complex.NAN.atanh(), Complex.NAN);
     }
 
     /**
@@ -174,8 +174,8 @@ public class CStandardTest {
         assertComplex(Complex.ZERO.cosh(), Complex.ONE);
         assertComplex(zeroInf.cosh(), nanZero);
         assertComplex(zeroNaN.cosh(), nanZero);
-        assertComplex(oneInf.cosh(), Complex.NaN);
-        assertComplex(oneNaN.cosh(), Complex.NaN);
+        assertComplex(oneInf.cosh(), Complex.NAN);
+        assertComplex(oneNaN.cosh(), Complex.NAN);
         assertComplex(infZero.cosh(), infZero);
         // the next test does not appear to make sense:
         // (inf + iy) = inf + cis(y)
@@ -183,8 +183,8 @@ public class CStandardTest {
         assertComplex(infInf.cosh(), infNaN);
         assertComplex(infNaN.cosh(), infNaN);
         assertComplex(nanZero.cosh(), nanZero);
-        assertComplex(nanOne.cosh(), Complex.NaN);
-        assertComplex(Complex.NaN.cosh(), Complex.NaN);
+        assertComplex(nanOne.cosh(), Complex.NAN);
+        assertComplex(Complex.NAN.cosh(), Complex.NAN);
     }
 
     /**
@@ -196,15 +196,15 @@ public class CStandardTest {
         assertComplex(Complex.ZERO.sinh(), Complex.ZERO);
         assertComplex(zeroInf.sinh(), zeroNaN);
         assertComplex(zeroNaN.sinh(), zeroNaN);
-        assertComplex(oneInf.sinh(), Complex.NaN);
-        assertComplex(oneNaN.sinh(), Complex.NaN);
+        assertComplex(oneInf.sinh(), Complex.NAN);
+        assertComplex(oneNaN.sinh(), Complex.NAN);
         assertComplex(infZero.sinh(), infZero);
         // skipped test similar to previous section
         assertComplex(infInf.sinh(), infNaN);
         assertComplex(infNaN.sinh(), infNaN);
         assertComplex(nanZero.sinh(), nanZero);
-        assertComplex(nanOne.sinh(), Complex.NaN);
-        assertComplex(Complex.NaN.sinh(), Complex.NaN);
+        assertComplex(nanOne.sinh(), Complex.NAN);
+        assertComplex(Complex.NAN.sinh(), Complex.NAN);
     }
 
     /**
@@ -214,14 +214,14 @@ public class CStandardTest {
     public void testTanh() {
         assertComplex(oneOne.tanh().conj(), oneOne.conj().tanh()); // AND CSINH IS ODD
         assertComplex(Complex.ZERO.tanh(), Complex.ZERO);
-        assertComplex(oneInf.tanh(), Complex.NaN);
-        assertComplex(oneNaN.tanh(), Complex.NaN);
+        assertComplex(oneInf.tanh(), Complex.NAN);
+        assertComplex(oneNaN.tanh(), Complex.NAN);
         //Do Not Understand the Next Test
         assertComplex(infInf.tanh(), oneZero);
         assertComplex(infNaN.tanh(), oneZero);
         assertComplex(nanZero.tanh(), nanZero);
-        assertComplex(nanOne.tanh(), Complex.NaN);
-        assertComplex(Complex.NaN.tanh(), Complex.NaN);
+        assertComplex(nanOne.tanh(), Complex.NAN);
+        assertComplex(Complex.NAN.tanh(), Complex.NAN);
     }
 
     /**
@@ -232,8 +232,8 @@ public class CStandardTest {
         assertComplex(oneOne.conj().exp(), oneOne.exp().conj());
         assertComplex(Complex.ZERO.exp(), oneZero);
         assertComplex(negZeroZero.exp(), oneZero);
-        assertComplex(oneInf.exp(), Complex.NaN);
-        assertComplex(oneNaN.exp(), Complex.NaN);
+        assertComplex(oneInf.exp(), Complex.NAN);
+        assertComplex(oneNaN.exp(), Complex.NAN);
         assertComplex(infZero.exp(), infZero);
         // Do not understand next test
         assertComplex(negInfInf.exp(), Complex.ZERO);
@@ -241,8 +241,8 @@ public class CStandardTest {
         assertComplex(negInfNaN.exp(), Complex.ZERO);
         assertComplex(infNaN.exp(), infNaN);
         assertComplex(nanZero.exp(), nanZero);
-        assertComplex(nanOne.exp(), Complex.NaN);
-        assertComplex(Complex.NaN.exp(), Complex.NaN);
+        assertComplex(nanOne.exp(), Complex.NAN);
+        assertComplex(Complex.NAN.exp(), Complex.NAN);
     }
 
     /**
@@ -254,14 +254,14 @@ public class CStandardTest {
         assertComplex(negZeroZero.log(), negInfPi); 
         assertComplex(Complex.ZERO.log(), negInfZero);
         assertComplex(oneInf.log(), infPiTwo);
-        assertComplex(oneNaN.log(), Complex.NaN);
+        assertComplex(oneNaN.log(), Complex.NAN);
         assertComplex(negInfOne.log(), infPi);
         assertComplex(infOne.log(), infZero);
         assertComplex(infInf.log(), infPiFour);
         assertComplex(infNaN.log(), infNaN);
-        assertComplex(nanOne.log(), Complex.NaN);
+        assertComplex(nanOne.log(), Complex.NAN);
         assertComplex(nanInf.log(), infNaN);
-        assertComplex(Complex.NaN.log(), Complex.NaN);
+        assertComplex(Complex.NAN.log(), Complex.NAN);
     }
 
     /**
@@ -276,7 +276,7 @@ public class CStandardTest {
         assertComplex(infOne.sqrt(), infZero);
         assertComplex(negInfNaN.sqrt(), nanInf);
         assertComplex(infNaN.sqrt(), infNaN);
-        assertComplex(nanOne.sqrt(), Complex.NaN);
-        assertComplex(Complex.NaN.sqrt(), Complex.NaN);
+        assertComplex(nanOne.sqrt(), Complex.NAN);
+        assertComplex(Complex.NAN.sqrt(), Complex.NAN);
     }
 }

http://git-wip-us.apache.org/repos/asf/commons-numbers/blob/2f1c0b5d/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java
----------------------------------------------------------------------
diff --git a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java
b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java
index b1ffab6..3e87320 100644
--- a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java
+++ b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java
@@ -81,7 +81,7 @@ public class ComplexTest {
 
     @Test
     public void testAbsNaN() {
-        Assert.assertTrue(Double.isNaN(Complex.NaN.abs()));
+        Assert.assertTrue(Double.isNaN(Complex.NAN.abs()));
         Complex z = new Complex(inf, nan);
         Assert.assertTrue(Double.isNaN(z.abs()));
     }
@@ -146,7 +146,7 @@ public class ComplexTest {
 
     @Test
     public void testConjugateNaN() {
-        Complex z = Complex.NaN.conjugate();
+        Complex z = Complex.NAN.conjugate();
         Assert.assertTrue(z.isNaN());
     }
 
@@ -187,20 +187,20 @@ public class ComplexTest {
         Complex x = new Complex(3.0, 4.0);
         Complex z = x.divide(Complex.ZERO);
         // Assert.assertEquals(z, Complex.INF); // See MATH-657
-        Assert.assertEquals(z, Complex.NaN);
+        Assert.assertEquals(z, Complex.NAN);
     }
 
     @Test
     public void testDivideZeroZero() {
         Complex x = new Complex(0.0, 0.0);
         Complex z = x.divide(Complex.ZERO);
-        Assert.assertEquals(z, Complex.NaN);
+        Assert.assertEquals(z, Complex.NAN);
     }
 
     @Test
     public void testDivideNaN() {
         Complex x = new Complex(3.0, 4.0);
-        Complex z = x.divide(Complex.NaN);
+        Complex z = x.divide(Complex.NAN);
         Assert.assertTrue(z.isNaN());
     }
 
@@ -274,7 +274,7 @@ public class ComplexTest {
 
     @Test
     public void testReciprocalNaN() {
-        Assert.assertTrue(Complex.NaN.reciprocal().isNaN());
+        Assert.assertTrue(Complex.NAN.reciprocal().isNaN());
     }
 
     @Test
@@ -333,7 +333,7 @@ public class ComplexTest {
 
     @Test
     public void testNegateNaN() {
-        Complex z = Complex.NaN.negate();
+        Complex z = Complex.NAN.negate();
         Assert.assertTrue(z.isNaN());
     }
 
@@ -521,7 +521,7 @@ public class ComplexTest {
         Complex realNaN = new Complex(Double.NaN, 0.0);
         Complex imaginaryNaN = new Complex(0.0, Double.NaN);
         Assert.assertEquals(realNaN.hashCode(), imaginaryNaN.hashCode());
-        Assert.assertEquals(imaginaryNaN.hashCode(), Complex.NaN.hashCode());
+        Assert.assertEquals(imaginaryNaN.hashCode(), Complex.NAN.hashCode());
 
         // MATH-1118
         // "equals" and "hashCode" must be compatible: if two objects have
@@ -578,7 +578,7 @@ public class ComplexTest {
 
     @Test
     public void testScalarPowNaNBase() {
-        Complex x = Complex.NaN;
+        Complex x = Complex.NAN;
         double yDouble = 5.0;
         Complex yComplex = new Complex(yDouble);
         Assert.assertEquals(x.pow(yComplex), x.pow(yDouble));
@@ -616,7 +616,7 @@ public class ComplexTest {
 
     @Test
     public void testSqrt1zNaN() {
-        Assert.assertTrue(Complex.NaN.sqrt1z().isNaN());
+        Assert.assertTrue(Complex.NAN.sqrt1z().isNaN());
     }
 
     /**
@@ -799,7 +799,7 @@ public class ComplexTest {
     public void testGetArgumentNaN() {
         Assert.assertTrue(Double.isNaN(nanZero.getArgument()));
         Assert.assertTrue(Double.isNaN(zeroNaN.getArgument()));
-        Assert.assertTrue(Double.isNaN(Complex.NaN.getArgument()));
+        Assert.assertTrue(Double.isNaN(Complex.NAN.getArgument()));
     }
 
     /*

http://git-wip-us.apache.org/repos/asf/commons-numbers/blob/2f1c0b5d/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexUtilsTest.java
----------------------------------------------------------------------
diff --git a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexUtilsTest.java
b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexUtilsTest.java
index 9a7a29d..3989797 100644
--- a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexUtilsTest.java
+++ b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexUtilsTest.java
@@ -209,17 +209,17 @@ public class ComplexUtilsTest {
 
     @Test
     public void testPolar2ComplexNaN() {
-        TestUtils.assertSame(Complex.NaN, ComplexUtils.polar2Complex(nan, 1));
-        TestUtils.assertSame(Complex.NaN, ComplexUtils.polar2Complex(1, nan));
-        TestUtils.assertSame(Complex.NaN, ComplexUtils.polar2Complex(nan, nan));
+        TestUtils.assertSame(Complex.NAN, ComplexUtils.polar2Complex(nan, 1));
+        TestUtils.assertSame(Complex.NAN, ComplexUtils.polar2Complex(1, nan));
+        TestUtils.assertSame(Complex.NAN, ComplexUtils.polar2Complex(nan, nan));
     }
 
     @Test
     public void testPolar2ComplexInf() {
-        TestUtils.assertSame(Complex.NaN, ComplexUtils.polar2Complex(1, inf));
-        TestUtils.assertSame(Complex.NaN, ComplexUtils.polar2Complex(1, negInf));
-        TestUtils.assertSame(Complex.NaN, ComplexUtils.polar2Complex(inf, inf));
-        TestUtils.assertSame(Complex.NaN, ComplexUtils.polar2Complex(inf, negInf));
+        TestUtils.assertSame(Complex.NAN, ComplexUtils.polar2Complex(1, inf));
+        TestUtils.assertSame(Complex.NAN, ComplexUtils.polar2Complex(1, negInf));
+        TestUtils.assertSame(Complex.NAN, ComplexUtils.polar2Complex(inf, inf));
+        TestUtils.assertSame(Complex.NAN, ComplexUtils.polar2Complex(inf, negInf));
         TestUtils.assertSame(infInf, ComplexUtils.polar2Complex(inf, pi / 4));
         TestUtils.assertSame(infNaN, ComplexUtils.polar2Complex(inf, 0));
         TestUtils.assertSame(infNegInf, ComplexUtils.polar2Complex(inf, -pi / 4));


Mime
View raw message