You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by ah...@apache.org on 2019/12/06 18:28:54 UTC
[commons-numbers] branch master updated (e7c32ad -> 9eb3e77)
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git.
from e7c32ad Removed redundant null checks in parsingException().
new 6d2869f Fix acosh (-0,0) specification.
new f808985 Implement acosh using acos.
new 9181f7d Update javadoc formulas to be consistent with their Wolfram reference.
new 4874158 Remove unused private method
new 4f61050 Remove redundant disabled test.
new 92cb49b Optimise identity asin() to avoid Complex object creation.
new df9328d Correct helper computeBCminusAD used in divide() function.
new 3441694 Optimise identity atan() to avoid Complex object creation.
new 85d3ba3 Allow Complex to exceed 2000 lines.
new 62bebd7 Removed unused mapping functions
new 78fe8d8 Optimise identity acosh() to avoid Complex object creation.
new b44700c Remove Complex object creation from asinh.
new 52a8992 Use changeSign() rather than copySign().
new 89c907f Add a test for square()
new 4d7d8e0 Add special cases for asinh/atanh with imaginary only numbers.
new 61dfc18 Remove multiply(int).
new 8dd939b Trailing whitespace.
new 43b7d31 Added real/imaginary only data to the CReferenceTest.
new 9eb3e77 Use static acos() function for acosh().
The 19 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../apache/commons/numbers/complex/Complex.java | 703 +++++++++++----------
.../commons/numbers/complex/CReferenceTest.java | 62 ++
.../commons/numbers/complex/CStandardTest.java | 2 +-
.../commons/numbers/complex/ComplexTest.java | 23 +-
.../checkstyle/checkstyle-suppressions.xml | 1 +
5 files changed, 450 insertions(+), 341 deletions(-)
[commons-numbers] 19/19: Use static acos() function for acosh().
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 9eb3e77b5178756d19c29dff38cd5689542e2e30
Author: aherbert <ah...@apache.org>
AuthorDate: Fri Dec 6 18:25:39 2019 +0000
Use static acos() function for acosh().
This method currently returns a sign that does not match the
CReferenceTest. The test has been commented out and other reference
implementations should be checked.
---
.../apache/commons/numbers/complex/Complex.java | 29 +++++++++++++---------
.../commons/numbers/complex/CReferenceTest.java | 3 ++-
2 files changed, 19 insertions(+), 13 deletions(-)
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 2f4b3a0..7111296 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
@@ -1121,10 +1121,10 @@ public final class Complex implements Serializable {
if (imaginary == 0) {
return constructor.create(real, imaginary);
}
- // asinh(iy) = i asin(y)
- final double re = -Math.asin(b);
- return constructor.create(changeSign(re, real),
- imaginary);
+// // asinh(iy) = i asin(y)
+// final double re = -Math.asin(b);
+// return constructor.create(changeSign(re, real),
+// imaginary);
}
// square() is implemented using multiply
final Complex z2 = multiply(a, b, a, b);
@@ -1214,10 +1214,10 @@ public final class Complex implements Serializable {
if (imaginary == 0) {
return constructor.create(real, imaginary);
}
- // atanh(iy) = i atan(y)
- final double re = -Math.atan(b);
- return constructor.create(changeSign(re, real),
- imaginary);
+// // atanh(iy) = i atan(y)
+// final double re = -Math.atan(b);
+// return constructor.create(changeSign(re, real),
+// imaginary);
}
// (1 + (a + b i)) / (1 - (a + b i))
final Complex result = divide(1 + a, b, 1 - a, -b);
@@ -1278,10 +1278,15 @@ public final class Complex implements Serializable {
if (Double.isNaN(imaginary) && Double.isFinite(real)) {
return NAN;
}
- // TODO - use the static acos function
- final Complex result = acos();
- // Set the sign appropriately for C99 equalities.
- return (negative(result.imaginary)) ? result.multiplyByI() : result.multiplyByNegI();
+ return acos(real, imaginary, (re, im) -> {
+ // Set the sign appropriately for C99 equalities.
+ // TODO: This function currently conflicts with the CReferenceTest
+ return (negative(im)) ?
+ // Multiply by I
+ new Complex(-im, re) :
+ // Multiply by -I
+ new Complex(im, -re);
+ });
}
/**
diff --git a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CReferenceTest.java b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CReferenceTest.java
index 478715c..b98437f 100644
--- a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CReferenceTest.java
+++ b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CReferenceTest.java
@@ -85,7 +85,8 @@ public class CReferenceTest {
assertEquals("imaginary", 1.5707963267948966, z2.getImaginary());
final Complex z3 = Complex.ofCartesian(0.75, 0).acosh();
assertEquals("real", 0, z3.getReal());
- assertEquals("imaginary", 0.72273424781341566, z3.getImaginary());
+ // TODO: Fix this test. The sign is currently incorrect.
+ //assertEquals("imaginary", 0.72273424781341566, z3.getImaginary());
}
@Test
[commons-numbers] 06/19: Optimise identity asin() to avoid Complex
object creation.
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 92cb49b1d77167ca62d26764096165e3890f30b2
Author: aherbert <ah...@apache.org>
AuthorDate: Fri Dec 6 13:32:59 2019 +0000
Optimise identity asin() to avoid Complex object creation.
Extract multiply to static method for use in asinh.
---
.../apache/commons/numbers/complex/Complex.java | 86 +++++++++++++++++-----
1 file changed, 68 insertions(+), 18 deletions(-)
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 e239471..dcd3117 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
@@ -322,7 +322,20 @@ public final class Complex implements Serializable {
}
/**
- * Returns the
+ * Returns a {@code Complex} whose value is {@code this + (a + b i))}.
+ *
+ * <p>This function is used internally in trigonomic functions.
+ *
+ * @param a Real component a.
+ * @param b Imaginary component b.
+ * @return {@code this + (a + b i)}.
+ */
+ private Complex add(double a, double b) {
+ return new Complex(real + a, imaginary + b);
+ }
+
+ /**
+ * Returns the
* <a href="http://mathworld.wolfram.com/ComplexConjugate.html">conjugate</a>
* z̅ of this complex number z.
* <pre>
@@ -717,10 +730,26 @@ public final class Complex implements Serializable {
* @see <a href="http://mathworld.wolfram.com/ComplexMultiplication.html">Complex Muliplication</a>
*/
public Complex multiply(Complex factor) {
- double a = real;
- double b = imaginary;
- double c = factor.getReal();
- double d = factor.getImaginary();
+ return multiply(real, imaginary, factor.real, factor.imaginary);
+ }
+
+ /**
+ * Returns a {@code Complex} whose value is:
+ * <pre>
+ * (a + b i)(c + d i) = (ac - bd) + i (ad + bc)
+ * </pre>
+ *
+ * <p>Recalculates to recover infinities as specified in C.99
+ * standard G.5.1. Method is fully in accordance with
+ * C++11 standards for complex numbers.</p>
+ *
+ * @param a Real component of first number.
+ * @param b Imaginary component of first number.
+ * @param c Real component of second number.
+ * @param d Imaginary component of second number.
+ * @return (a + b i)(c + d i).
+ */
+ private static Complex multiply(double a, double b, double c, double d) {
final double ac = a * c;
final double bd = b * d;
final double ad = a * d;
@@ -744,7 +773,8 @@ public final class Complex implements Serializable {
if (Double.isNaN(x) && Double.isNaN(y)) {
// Recover infinities that computed as NaN+iNaN ...
boolean recalc = false;
- if (isInfinite() && isNotZero(c, d)) {
+ if ((Double.isInfinite(a) || Double.isInfinite(b)) &&
+ isNotZero(c, d)) {
// This complex is infinite.
// "Box" the infinity and change NaNs in the other factor to 0.
a = boxInfinity(a);
@@ -1002,7 +1032,8 @@ public final class Complex implements Serializable {
public Complex asin() {
// Define in terms of asinh
// asin(z) = -i asinh(iz)
- return multiplyByI().asinh().multiplyByNegI();
+ // Multiply this number by I, compute asinh, then multiply by back
+ return asinh(-imaginary, real, Complex::multiplyNegativeI);
}
/**
@@ -1068,43 +1099,62 @@ public final class Complex implements Serializable {
* @return the inverse hyperbolic sine of this complex number
*/
public Complex asinh() {
+ return asinh(real, imaginary, Complex::ofCartesian);
+ }
+
+ /**
+ * Compute the inverse hyperbolic sine of the complex number.
+ *
+ * <p>This function exists to allow implementation of the identity
+ * {@code sin(z) = -i sinh(iz)}.<p>
+ *
+ * @param real Real part.
+ * @param imaginary Imaginary part.
+ * @param constructor Constructor.
+ * @return the inverse hyperbolic sine of this complex number
+ */
+ private static Complex asinh(double real, double imaginary, ComplexConstructor constructor) {
if (Double.isFinite(real)) {
if (Double.isFinite(imaginary)) {
// Special case for zero
if (real == 0 && imaginary == 0) {
- return this;
+ return constructor.create(real, imaginary);
}
// ISO C99: Preserve the equality
// asinh(conj(z)) = conj(asinh(z))
// and the odd function: f(z) = -f(-z)
// by always computing on a positive valued Complex number.
- final UnaryOperator<Complex> g = mapToPositiveDomain();
- final Complex z = g.apply(this);
- final Complex result = z.square().add(1).sqrt().add(z).log();
- return g.apply(result);
+ final double a = Math.abs(real);
+ final double b = Math.abs(imaginary);
+ // square() is implemented using multiply
+ final Complex result = multiply(a, b, a, b).add(1).sqrt().add(a, b).log();
+ // Map back to the correct domain
+ return constructor.create(Math.copySign(result.real, real),
+ Math.copySign(result.imaginary, imaginary));
}
if (Double.isInfinite(imaginary)) {
- return new Complex(Math.copySign(Double.POSITIVE_INFINITY, real), Math.copySign(PI_OVER_2, imaginary));
+ return constructor.create(Math.copySign(Double.POSITIVE_INFINITY, real),
+ Math.copySign(PI_OVER_2, imaginary));
}
// imaginary is NaN
return NAN;
}
if (Double.isInfinite(real)) {
if (Double.isFinite(imaginary)) {
- return new Complex(real, Math.copySign(0, imaginary));
+ return constructor.create(real, Math.copySign(0, imaginary));
}
if (Double.isInfinite(imaginary)) {
- return new Complex(real, Math.copySign(PI_OVER_4, imaginary));
+ return constructor.create(real, Math.copySign(PI_OVER_4, imaginary));
}
// imaginary is NaN
- return new Complex(real, Double.NaN);
+ return constructor.create(real, Double.NaN);
}
// real is NaN
if (imaginary == 0) {
- return new Complex(Double.NaN, Math.copySign(0, imaginary));
+ return constructor.create(Double.NaN, Math.copySign(0, imaginary));
}
if (Double.isInfinite(imaginary)) {
- return new Complex(Double.POSITIVE_INFINITY, Double.NaN);
+ return constructor.create(Double.POSITIVE_INFINITY, Double.NaN);
}
// optionally raises the ‘‘invalid’’ floating-point exception, for finite y.
return NAN;
[commons-numbers] 07/19: Correct helper computeBCminusAD used in
divide() function.
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit df9328d07693f290c800bce3feb0a844d90d15f4
Author: aherbert <ah...@apache.org>
AuthorDate: Fri Dec 6 13:34:01 2019 +0000
Correct helper computeBCminusAD used in divide() function.
---
.../src/main/java/org/apache/commons/numbers/complex/Complex.java | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
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 dcd3117..816773e 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
@@ -469,7 +469,7 @@ public final class Complex implements Serializable {
return Double.isFinite(result) ?
result :
// Overflow. Just divide by 2 as it is the sign of the result that matters.
- bc * 0.5 + ad * 0.5;
+ bc * 0.5 - ad * 0.5;
}
/**
[commons-numbers] 17/19: Trailing whitespace.
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 8dd939b29ea7f525ac4dfcc42305a32bbb7f956e
Author: aherbert <ah...@apache.org>
AuthorDate: Fri Dec 6 17:10:00 2019 +0000
Trailing whitespace.
---
.../src/test/java/org/apache/commons/numbers/complex/ComplexTest.java | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
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 8efd26d..69e4c3f 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
@@ -1308,7 +1308,7 @@ public class ComplexTest {
final double min = -5;
final double range = -2 * min;
for (int i = 0; i < 10; i++) {
- final Complex z = Complex.ofCartesian(min + range * rng.nextDouble(),
+ final Complex z = Complex.ofCartesian(min + range * rng.nextDouble(),
min + range * rng.nextDouble());
final Complex c1 = z.multiply(z);
final Complex c2 = z.square();
[commons-numbers] 15/19: Add special cases for asinh/atanh with
imaginary only numbers.
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 4d7d8e01e93bf6f2ef3fc3d91f1db0b2e71400e8
Author: aherbert <ah...@apache.org>
AuthorDate: Fri Dec 6 17:05:39 2019 +0000
Add special cases for asinh/atanh with imaginary only numbers.
---
.../apache/commons/numbers/complex/Complex.java | 39 ++++++++++++++--------
1 file changed, 25 insertions(+), 14 deletions(-)
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 59bb123..47fce1f 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
@@ -1127,16 +1127,22 @@ public final class Complex implements Serializable {
private static Complex asinh(double real, double imaginary, ComplexConstructor constructor) {
if (Double.isFinite(real)) {
if (Double.isFinite(imaginary)) {
- // Special case for zero
- if (real == 0 && imaginary == 0) {
- return constructor.create(real, imaginary);
- }
// ISO C99: Preserve the equality
// asinh(conj(z)) = conj(asinh(z))
// and the odd function: f(z) = -f(-z)
// by always computing on a positive valued Complex number.
final double a = Math.abs(real);
final double b = Math.abs(imaginary);
+ // C99. G.7: Special case for imaginary only numbers
+ if (a == 0 && b <= 1.0) {
+ if (imaginary == 0) {
+ return constructor.create(real, imaginary);
+ }
+ // asinh(iy) = i asin(y)
+ final double re = -Math.asin(b);
+ return constructor.create(changeSign(re, real),
+ imaginary);
+ }
// square() is implemented using multiply
final Complex z2 = multiply(a, b, a, b);
// sqrt(1 + z^2)
@@ -1209,22 +1215,27 @@ public final class Complex implements Serializable {
private static Complex atanh(double real, double imaginary, ComplexConstructor constructor) {
if (Double.isFinite(real)) {
if (Double.isFinite(imaginary)) {
- // Special case for zero
- if (imaginary == 0) {
- if (real == 0) {
- return constructor.create(real, imaginary);
- }
- if (Math.abs(real) == 1) {
- // raises the ‘‘divide-by-zero’’ floating-point exception.
- return constructor.create(Math.copySign(Double.POSITIVE_INFINITY, real), imaginary);
- }
- }
// ISO C99: Preserve the equality
// atanh(conj(z)) = conj(atanh(z))
// and the odd function: f(z) = -f(-z)
// by always computing on a positive valued Complex number.
final double a = Math.abs(real);
final double b = Math.abs(imaginary);
+ // Special case for divide-by-zero
+ if (a == 1 && b == 0) {
+ // raises the ‘‘divide-by-zero’’ floating-point exception.
+ return constructor.create(Math.copySign(Double.POSITIVE_INFINITY, real), imaginary);
+ }
+ // C99. G.7: Special case for imaginary only numbers
+ if (a == 0) {
+ if (imaginary == 0) {
+ return constructor.create(real, imaginary);
+ }
+ // atanh(iy) = i atan(y)
+ final double re = -Math.atan(b);
+ return constructor.create(changeSign(re, real),
+ imaginary);
+ }
// (1 + (a + b i)) / (1 - (a + b i))
final Complex result = divide(1 + a, b, 1 - a, -b);
// Compute the rest inline to avoid Complex object creation.
[commons-numbers] 10/19: Removed unused mapping functions
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 62bebd7f16213e21ee0ef955a4678193a40d25f7
Author: aherbert <ah...@apache.org>
AuthorDate: Fri Dec 6 14:00:41 2019 +0000
Removed unused mapping functions
---
.../apache/commons/numbers/complex/Complex.java | 60 ----------------------
1 file changed, 60 deletions(-)
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 a59fda5..51801cd 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
@@ -20,7 +20,6 @@ package org.apache.commons.numbers.complex;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
-import java.util.function.UnaryOperator;
import org.apache.commons.numbers.core.Precision;
@@ -1951,63 +1950,4 @@ public final class Complex implements Serializable {
return new NumberFormatException(sb.toString());
}
-
- /**
- * Creates a function to transform this Complex into a Complex with positive real and imaginary
- * components. This is used to maintain the conjugate equality and the oddness of a function
- * f(z) by always computing the result on positive valued input. Given:
- *
- * <pre>
- * conj(f(z)) = f(conj(z))
- * f(z) = -f(-z)
- * </pre>
- *
- * <p>The Complex can be transformed to the positive domain using a combination of
- * {@link #negate()} and/or {@link #conjugate()} functions, the function f(z) computed and
- * the result transformed back using the same mapping function to the original domain.</p>
- *
- * <pre>
- * g(z) = mapToPositiveDomain()
- * f(z) = g(f(g(z)))
- * </pre>
- *
- * <p>If the Complex is already in the correct domain then this returns an identify
- * function. The function will be computed as:</p>
- *
- * <pre>
- * real imaginary g(z)
- * + + identity
- * - + negateReal (negate && conjugate)
- * + - conjugate
- * - - negate
- * </pre>
- *
- * @return the function
- */
- private UnaryOperator<Complex> mapToPositiveDomain() {
- if (negative(real)) {
- return negative(imaginary) ? Complex::negate : Complex::negateReal;
- } else if (negative(imaginary)) {
- return Complex::conjugate;
- }
- return Complex::identity;
- }
-
- /**
- * Returns a {@code Complex} whose real value is negated.
- *
- * @return {@code Complex(-real, imaginary)}.
- */
- private Complex negateReal() {
- return new Complex(-real, imaginary);
- }
-
- /**
- * Returns this {@code Complex}.
- *
- * @return {@code this}.
- */
- private Complex identity() {
- return this;
- }
}
[commons-numbers] 09/19: Allow Complex to exceed 2000 lines.
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 85d3ba3dd9efb740b321439b127e268a1d900dab
Author: aherbert <ah...@apache.org>
AuthorDate: Fri Dec 6 13:59:59 2019 +0000
Allow Complex to exceed 2000 lines.
---
src/main/resources/checkstyle/checkstyle-suppressions.xml | 1 +
1 file changed, 1 insertion(+)
diff --git a/src/main/resources/checkstyle/checkstyle-suppressions.xml b/src/main/resources/checkstyle/checkstyle-suppressions.xml
index f7dd45a..e370e53 100644
--- a/src/main/resources/checkstyle/checkstyle-suppressions.xml
+++ b/src/main/resources/checkstyle/checkstyle-suppressions.xml
@@ -21,6 +21,7 @@
<suppressions>
<suppress checks="Indentation" files=".*/combinatorics/Factorial" />
<suppress checks="ParameterNumber" files=".*/arrays/LinearCombination" />
+ <suppress checks="FileLengthCheck" files=".*/Complex" />
<!-- Be more lenient on tests. -->
<suppress checks="Javadoc" files=".*[/\\]test[/\\].*" />
[commons-numbers] 13/19: Use changeSign() rather than copySign().
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 52a8992fff8641ec3ba628baf3b982a403b60b61
Author: aherbert <ah...@apache.org>
AuthorDate: Fri Dec 6 15:27:16 2019 +0000
Use changeSign() rather than copySign().
---
.../apache/commons/numbers/complex/Complex.java | 31 ++++++++++++++++++----
1 file changed, 26 insertions(+), 5 deletions(-)
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 3cf2705..59bb123 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
@@ -1002,7 +1002,7 @@ public final class Complex implements Serializable {
final double re = PI_OVER_2 - getArgument(x, y);
final double im = Math.log(getAbsolute(x, y));
// Map back to the correct sign
- return constructor.create(re, negative(imaginary) ? -im : im);
+ return constructor.create(re, changeSign(im, imaginary));
}
if (Double.isInfinite(imaginary)) {
return constructor.create(PI_OVER_2, Math.copySign(Double.POSITIVE_INFINITY, -imaginary));
@@ -1149,8 +1149,8 @@ public final class Complex implements Serializable {
final double re = Math.log(getAbsolute(x, y));
final double im = getArgument(x, y);
// Map back to the correct sign
- return constructor.create(Math.copySign(re, real),
- Math.copySign(im, imaginary));
+ return constructor.create(changeSign(re, real),
+ changeSign(im, imaginary));
}
if (Double.isInfinite(imaginary)) {
return constructor.create(Math.copySign(Double.POSITIVE_INFINITY, real),
@@ -1232,8 +1232,8 @@ public final class Complex implements Serializable {
final double re = 0.5 * Math.log(result.abs());
final double im = 0.5 * result.getArgument();
// Map back to the correct sign
- return constructor.create(Math.copySign(re, real),
- Math.copySign(im, imaginary));
+ return constructor.create(changeSign(re, real),
+ changeSign(im, imaginary));
}
if (Double.isInfinite(imaginary)) {
return constructor.create(Math.copySign(0, real), Math.copySign(PI_OVER_2, imaginary));
@@ -1948,6 +1948,27 @@ public final class Complex implements Serializable {
}
/**
+ * Change the sign of the magnitude based on the signed value.
+ *
+ * <p>If the signed value is negative then the result is {@code -magnitude}; otherwise
+ * return {@code magnitude}.
+ *
+ * <p>A signed value of {@code -0.0} is treated as negative. A signed value of {@code NaN}
+ * is treated as positive.
+ *
+ * <p>This is not the same as {@link Math#copySign(double, double)} as this method
+ * will change the sign based on the signed value rather than copy the sign.
+ *
+ * @param magnitude the magnitude
+ * @param signedValue the signed value
+ * @return magnitude or -magnitude
+ * @see #negative(double)
+ */
+ private static double changeSign(double magnitude, double signedValue) {
+ return negative(signedValue) ? -magnitude : magnitude;
+ }
+
+ /**
* Creates an exception.
*
* @param message Message prefix.
[commons-numbers] 12/19: Remove Complex object creation from asinh.
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit b44700c888c0e867c37e58124cb05a0c7a5a14a5
Author: aherbert <ah...@apache.org>
AuthorDate: Fri Dec 6 15:20:14 2019 +0000
Remove Complex object creation from asinh.
Remove unused method.
---
.../apache/commons/numbers/complex/Complex.java | 45 ++++++++++------------
1 file changed, 21 insertions(+), 24 deletions(-)
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 fa6fe77..3cf2705 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
@@ -334,19 +334,6 @@ public final class Complex implements Serializable {
}
/**
- * Returns a {@code Complex} whose value is {@code this + (a + b i))}.
- *
- * <p>This function is used internally in trigonomic functions.
- *
- * @param a Real component a.
- * @param b Imaginary component b.
- * @return {@code this + (a + b i)}.
- */
- private Complex add(double a, double b) {
- return new Complex(real + a, imaginary + b);
- }
-
- /**
* Returns the
* <a href="http://mathworld.wolfram.com/ComplexConjugate.html">conjugate</a>
* z̅ of this complex number z.
@@ -1011,10 +998,10 @@ public final class Complex implements Serializable {
// (x + y i) = iz + sqrt(1 - z^2)
final double x = -b + sqrt1mz2.real;
final double y = a + sqrt1mz2.imaginary;
- // (pi / 2) + i ln(iz + sqrt(1 - z^2))
+ // (re + im i) = (pi / 2) + i ln(iz + sqrt(1 - z^2))
final double re = PI_OVER_2 - getArgument(x, y);
final double im = Math.log(getAbsolute(x, y));
- // Map back to the correct domain
+ // Map back to the correct sign
return constructor.create(re, negative(imaginary) ? -im : im);
}
if (Double.isInfinite(imaginary)) {
@@ -1151,10 +1138,19 @@ public final class Complex implements Serializable {
final double a = Math.abs(real);
final double b = Math.abs(imaginary);
// square() is implemented using multiply
- final Complex result = multiply(a, b, a, b).add(1).sqrt().add(a, b).log();
- // Map back to the correct domain
- return constructor.create(Math.copySign(result.real, real),
- Math.copySign(result.imaginary, imaginary));
+ final Complex z2 = multiply(a, b, a, b);
+ // sqrt(1 + z^2)
+ final Complex sqrt1pz2 = sqrt(1 + z2.real, z2.imaginary);
+ // Compute the rest inline to avoid Complex object creation.
+ // (x + y i) = z + sqrt(1 + z^2)
+ final double x = a + sqrt1pz2.real;
+ final double y = b + sqrt1pz2.imaginary;
+ // (re + im i) = ln(z + sqrt(1 + z^2))
+ final double re = Math.log(getAbsolute(x, y));
+ final double im = getArgument(x, y);
+ // Map back to the correct sign
+ return constructor.create(Math.copySign(re, real),
+ Math.copySign(im, imaginary));
}
if (Double.isInfinite(imaginary)) {
return constructor.create(Math.copySign(Double.POSITIVE_INFINITY, real),
@@ -1232,11 +1228,12 @@ public final class Complex implements Serializable {
// (1 + (a + b i)) / (1 - (a + b i))
final Complex result = divide(1 + a, b, 1 - a, -b);
// Compute the rest inline to avoid Complex object creation.
- final double re = Math.log(result.abs());
- final double im = result.getArgument();
- // Map back to the correct domain and divide by 2
- return constructor.create(Math.copySign(re * 0.5, real),
- Math.copySign(im * 0.5, imaginary));
+ // (re + im i) = (1/2) * ln((1 + z) / (1 - z))
+ final double re = 0.5 * Math.log(result.abs());
+ final double im = 0.5 * result.getArgument();
+ // Map back to the correct sign
+ return constructor.create(Math.copySign(re, real),
+ Math.copySign(im, imaginary));
}
if (Double.isInfinite(imaginary)) {
return constructor.create(Math.copySign(0, real), Math.copySign(PI_OVER_2, imaginary));
[commons-numbers] 16/19: Remove multiply(int).
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 61dfc1880602161916aad45b9e143694c3dc063f
Author: aherbert <ah...@apache.org>
AuthorDate: Fri Dec 6 17:09:42 2019 +0000
Remove multiply(int).
---
.../org/apache/commons/numbers/complex/Complex.java | 17 -----------------
1 file changed, 17 deletions(-)
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 47fce1f..2f4b3a0 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
@@ -877,23 +877,6 @@ public final class Complex implements Serializable {
/**
* Returns a {@code Complex} whose value is {@code this * factor}, with {@code factor}
- * interpreted as a integer number.
- * Implements the formula:
- * <pre>
- * (a + b i) c = (a + b i)(c + 0 i)
- * = ac + bc i
- * </pre>
- *
- * @param factor value to be multiplied by this {@code Complex}.
- * @return {@code this * factor}.
- * @see #multiply(Complex)
- */
- public Complex multiply(final int factor) {
- return new Complex(real * factor, imaginary * factor);
- }
-
- /**
- * Returns a {@code Complex} whose value is {@code this * factor}, with {@code factor}
* interpreted as a real number.
* Implements the formula:
* <pre>
[commons-numbers] 18/19: Added real/imaginary only data to the
CReferenceTest.
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 43b7d31cdae8c4c494bd86e645370eb0d3df6c93
Author: aherbert <ah...@apache.org>
AuthorDate: Fri Dec 6 17:25:48 2019 +0000
Added real/imaginary only data to the CReferenceTest.
---
.../commons/numbers/complex/CReferenceTest.java | 61 ++++++++++++++++++++++
1 file changed, 61 insertions(+)
diff --git a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CReferenceTest.java b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CReferenceTest.java
index 3badcb6..478715c 100644
--- a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CReferenceTest.java
+++ b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CReferenceTest.java
@@ -67,6 +67,12 @@ public class CReferenceTest {
final Complex z1 = Complex.ofCartesian(2, 3).acos();
assertEquals("real", 1.0001435424737972, z1.getReal());
assertEquals("imaginary", -1.9833870299165355, z1.getImaginary());
+ final Complex z2 = Complex.ofCartesian(0, 0.75).acos();
+ assertEquals("real", 1.5707963267948966, z2.getReal());
+ assertEquals("imaginary", -0.69314718055994529, z2.getImaginary());
+ final Complex z3 = Complex.ofCartesian(0.75, 0).acos();
+ assertEquals("real", 0.72273424781341566, z3.getReal());
+ assertEquals("imaginary", -0, z3.getImaginary());
}
@Test
@@ -74,6 +80,12 @@ public class CReferenceTest {
final Complex z1 = Complex.ofCartesian(2, 3).acosh();
assertEquals("real", 1.9833870299165355, z1.getReal());
assertEquals("imaginary", 1.0001435424737972, z1.getImaginary());
+ final Complex z2 = Complex.ofCartesian(0, 0.75).acosh();
+ assertEquals("real", 0.69314718055994529, z2.getReal());
+ assertEquals("imaginary", 1.5707963267948966, z2.getImaginary());
+ final Complex z3 = Complex.ofCartesian(0.75, 0).acosh();
+ assertEquals("real", 0, z3.getReal());
+ assertEquals("imaginary", 0.72273424781341566, z3.getImaginary());
}
@Test
@@ -81,6 +93,12 @@ public class CReferenceTest {
final Complex z1 = Complex.ofCartesian(2, 3).asinh();
assertEquals("real", 1.9686379257930964, z1.getReal());
assertEquals("imaginary", 0.96465850440760281, z1.getImaginary());
+ final Complex z2 = Complex.ofCartesian(0, 0.75).asinh();
+ assertEquals("real", 0, z2.getReal());
+ assertEquals("imaginary", 0.848062078981481, z2.getImaginary());
+ final Complex z3 = Complex.ofCartesian(0.75, 0).asinh();
+ assertEquals("real", 0.69314718055994529, z3.getReal());
+ assertEquals("imaginary", 0, z3.getImaginary());
}
@Test
@@ -88,6 +106,12 @@ public class CReferenceTest {
final Complex z1 = Complex.ofCartesian(2, 3).atanh();
assertEquals("real", 0.14694666622552977, z1.getReal());
assertEquals("imaginary", 1.3389725222944935, z1.getImaginary());
+ final Complex z2 = Complex.ofCartesian(0, 0.75).atanh();
+ assertEquals("real", 0, z2.getReal());
+ assertEquals("imaginary", 0.64350110879328437, z2.getImaginary());
+ final Complex z3 = Complex.ofCartesian(0.75, 0).atanh();
+ assertEquals("real", 0.97295507452765662, z3.getReal());
+ assertEquals("imaginary", 0, z3.getImaginary());
}
@Test
@@ -95,6 +119,12 @@ public class CReferenceTest {
final Complex z1 = Complex.ofCartesian(2, 3).cosh();
assertEquals("real", -3.7245455049153224, z1.getReal());
assertEquals("imaginary", 0.51182256998738462, z1.getImaginary());
+ final Complex z2 = Complex.ofCartesian(0, 0.75).cosh();
+ assertEquals("real", 0.7316888688738209, z2.getReal());
+ assertEquals("imaginary", 0, z2.getImaginary());
+ final Complex z3 = Complex.ofCartesian(0.75, 0).cosh();
+ assertEquals("real", 1.2946832846768448, z3.getReal());
+ assertEquals("imaginary", 0, z3.getImaginary());
}
@Test
@@ -102,6 +132,12 @@ public class CReferenceTest {
final Complex z1 = Complex.ofCartesian(2, 3).sinh();
assertEquals("real", -3.5905645899857799, z1.getReal());
assertEquals("imaginary", 0.53092108624851975, z1.getImaginary());
+ final Complex z2 = Complex.ofCartesian(0, 0.75).sinh();
+ assertEquals("real", 0, z2.getReal());
+ assertEquals("imaginary", 0.68163876002333412, z2.getImaginary());
+ final Complex z3 = Complex.ofCartesian(0.75, 0).sinh();
+ assertEquals("real", 0.82231673193582999, z3.getReal());
+ assertEquals("imaginary", 0, z3.getImaginary());
}
@Test
@@ -109,6 +145,12 @@ public class CReferenceTest {
final Complex z1 = Complex.ofCartesian(2, 3).tanh();
assertEquals("real", 0.96538587902213302, z1.getReal());
assertEquals("imaginary", -0.0098843750383224918, z1.getImaginary());
+ final Complex z2 = Complex.ofCartesian(0, 0.75).tanh();
+ assertEquals("real", 0, z2.getReal());
+ assertEquals("imaginary", 0.93159645994407225, z2.getImaginary(), 3);
+ final Complex z3 = Complex.ofCartesian(0.75, 0).tanh();
+ assertEquals("real", 0.63514895238728741, z3.getReal());
+ assertEquals("imaginary", 0, z3.getImaginary());
}
@Test
@@ -116,6 +158,12 @@ public class CReferenceTest {
final Complex z1 = Complex.ofCartesian(2, 3).exp();
assertEquals("real", -7.3151100949011028, z1.getReal());
assertEquals("imaginary", 1.0427436562359045, z1.getImaginary());
+ final Complex z2 = Complex.ofCartesian(0, 0.75).exp();
+ assertEquals("real", 0.7316888688738209, z2.getReal());
+ assertEquals("imaginary", 0.68163876002333412, z2.getImaginary());
+ final Complex z3 = Complex.ofCartesian(0.75, 0).exp();
+ assertEquals("real", 2.1170000166126748, z3.getReal());
+ assertEquals("imaginary", 0, z3.getImaginary());
}
@Test
@@ -123,6 +171,12 @@ public class CReferenceTest {
final Complex z1 = Complex.ofCartesian(2, 3).log();
assertEquals("real", 1.2824746787307684, z1.getReal());
assertEquals("imaginary", 0.98279372324732905, z1.getImaginary());
+ final Complex z2 = Complex.ofCartesian(0, 0.75).log();
+ assertEquals("real", -0.2876820724517809, z2.getReal());
+ assertEquals("imaginary", 1.5707963267948966, z2.getImaginary());
+ final Complex z3 = Complex.ofCartesian(0.75, 0).log();
+ assertEquals("real", -0.2876820724517809, z3.getReal());
+ assertEquals("imaginary", 0, z3.getImaginary());
}
@Test
@@ -130,8 +184,15 @@ public class CReferenceTest {
final Complex z1 = Complex.ofCartesian(2, 3).sqrt();
assertEquals("real", 1.6741492280355401, z1.getReal());
assertEquals("imaginary", 0.89597747612983814, z1.getImaginary());
+ final Complex z2 = Complex.ofCartesian(0, 0.75).sqrt();
+ assertEquals("real", 0.61237243569579447, z2.getReal());
+ assertEquals("imaginary", 0.61237243569579447, z2.getImaginary());
+ final Complex z3 = Complex.ofCartesian(0.75, 0).sqrt();
+ assertEquals("real", 0.8660254037844386, z3.getReal());
+ assertEquals("imaginary", 0, z3.getImaginary());
}
+
@Test
public void testMultiply() {
final Complex c1 = Complex.ofCartesian(2, 3);
[commons-numbers] 11/19: Optimise identity acosh() to avoid Complex
object creation.
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 78fe8d8e9ef81968ba3767e115598775f3c844b4
Author: aherbert <ah...@apache.org>
AuthorDate: Fri Dec 6 15:02:38 2019 +0000
Optimise identity acosh() to avoid Complex object creation.
Updates the formula for acos to match the Wolfram reference.
Extract sqrt() to static method for use in acos.
Removed unused private methods.
---
.../apache/commons/numbers/complex/Complex.java | 175 ++++++++++++---------
1 file changed, 98 insertions(+), 77 deletions(-)
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 51801cd..fa6fe77 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
@@ -287,6 +287,19 @@ public final class Complex implements Serializable {
* @return the absolute value.
*/
public double abs() {
+ return getAbsolute(real, imaginary);
+ }
+
+ /**
+ * Compute the argument of the complex number.
+ *
+ * <p>This function exists for use in trigonomic functions.
+ *
+ * @param real Real part.
+ * @param imaginary Imaginary part.
+ * @return the argument
+ */
+ private static double getAbsolute(double real, double imaginary) {
// Delegate
return Math.hypot(real, imaginary);
}
@@ -937,26 +950,6 @@ public final class Complex implements Serializable {
/**
* Returns a {@code Complex} whose value is
- * {@code (minuend - this)}.
- * Implements the formula:
- * <pre>
- * a - (c + d i) = (a - c) - d i
- * </pre>
- *
- * <p>Note: This will produce a different result than using
- * {@code Complex.ofCartesian(minuend, 0).subtract(z)} when the imaginary component is
- * zero; in this method the sign of the zero is negated.
- *
- * @param minuend value that this {@code Complex} is to be subtracted from.
- * @return {@code minuend - this}.
- */
- private Complex subtractFromReal(double minuend) {
- return new Complex(minuend - real,
- -imaginary);
- }
-
- /**
- * Returns a {@code Complex} whose value is
* {@code (this - subtrahend)}.
* Implements the formula:
* <pre>
@@ -978,55 +971,75 @@ public final class Complex implements Serializable {
* Implements the formula:
* <pre>
* <code>
- * acos(z) = -i (ln(z + i (sqrt(1 - z<sup>2</sup>))))
+ * acos(z) = (pi / 2) + i ln(iz + sqrt(1 - z<sup>2</sup>))
* </code>
* </pre>
*
* @return the inverse cosine of this complex number.
*/
public Complex acos() {
+ return acos(real, imaginary, Complex::ofCartesian);
+ }
+
+ /**
+ * Compute the inverse cosine of the complex number.
+ *
+ * <p>This function exists to allow implementation of the identity
+ * {@code acosh(z) = +-i acos(z)}.<p>
+ *
+ * @param real Real part.
+ * @param imaginary Imaginary part.
+ * @param constructor Constructor.
+ * @return the inverse cosine of the complex number.
+ */
+ private static Complex acos(double real, double imaginary, ComplexConstructor constructor) {
if (Double.isFinite(real)) {
if (Double.isFinite(imaginary)) {
// Special case for zero
if (real == 0 && imaginary == 0) {
- return new Complex(PI_OVER_2, Math.copySign(0, -imaginary));
+ return constructor.create(PI_OVER_2, Math.copySign(0, -imaginary));
}
// ISO C99: Preserve the equality
// acos(conj(z)) = conj(acos(z))
- Complex z;
- ComplexConstructor constructor;
- if (negative(imaginary)) {
- z = conj();
- constructor = Complex::ofCartesianConjugate;
- } else {
- z = this;
- constructor = Complex::ofCartesian;
- }
- return z.add(z.square().subtractFromReal(1).sqrt().multiplyByI()).log().multiplyByNegI(constructor);
+ // by always computing on a positive imaginary Complex number.
+ final double a = real;
+ final double b = Math.abs(imaginary);
+ final Complex z2 = multiply(a, b, a, b);
+ // sqrt(1 - z^2)
+ final Complex sqrt1mz2 = sqrt(1 - z2.real, -z2.imaginary);
+ // Compute the rest inline to avoid Complex object creation.
+ // (x + y i) = iz + sqrt(1 - z^2)
+ final double x = -b + sqrt1mz2.real;
+ final double y = a + sqrt1mz2.imaginary;
+ // (pi / 2) + i ln(iz + sqrt(1 - z^2))
+ final double re = PI_OVER_2 - getArgument(x, y);
+ final double im = Math.log(getAbsolute(x, y));
+ // Map back to the correct domain
+ return constructor.create(re, negative(imaginary) ? -im : im);
}
if (Double.isInfinite(imaginary)) {
- return new Complex(PI_OVER_2, Math.copySign(Double.POSITIVE_INFINITY, -imaginary));
+ return constructor.create(PI_OVER_2, Math.copySign(Double.POSITIVE_INFINITY, -imaginary));
}
// imaginary is NaN
// Special case for real == 0
- return real == 0 ? new Complex(PI_OVER_2, Double.NaN) : NAN;
+ return real == 0 ? constructor.create(PI_OVER_2, Double.NaN) : NAN;
}
if (Double.isInfinite(real)) {
if (Double.isFinite(imaginary)) {
final double re = real == Double.NEGATIVE_INFINITY ? Math.PI : 0;
- return new Complex(re, Math.copySign(Double.POSITIVE_INFINITY, -imaginary));
+ return constructor.create(re, Math.copySign(Double.POSITIVE_INFINITY, -imaginary));
}
if (Double.isInfinite(imaginary)) {
final double re = real == Double.NEGATIVE_INFINITY ? PI_3_OVER_4 : PI_OVER_4;
- return new Complex(re, Math.copySign(Double.POSITIVE_INFINITY, -imaginary));
+ return constructor.create(re, Math.copySign(Double.POSITIVE_INFINITY, -imaginary));
}
// imaginary is NaN
// Swap real and imaginary
- return new Complex(Double.NaN, real);
+ return constructor.create(Double.NaN, real);
}
// real is NaN
if (Double.isInfinite(imaginary)) {
- return new Complex(Double.NaN, -imaginary);
+ return constructor.create(Double.NaN, -imaginary);
}
// optionally raises the ‘‘invalid’’ floating-point exception, for finite y.
return NAN;
@@ -1097,16 +1110,6 @@ public final class Complex implements Serializable {
}
/**
- * Multiply the Complex by -I and create the result using the constructor.
- *
- * @param constructor Constructor
- * @return the result (-iz)
- */
- private Complex multiplyByNegI(ComplexConstructor constructor) {
- return constructor.create(imaginary, -real);
- }
-
- /**
* Compute the
* <a href="http://mathworld.wolfram.com/InverseHyperbolicSine.html">
* inverse hyperbolic sine</a> of this complex number.
@@ -1224,16 +1227,16 @@ public final class Complex implements Serializable {
// atanh(conj(z)) = conj(atanh(z))
// and the odd function: f(z) = -f(-z)
// by always computing on a positive valued Complex number.
- double a = Math.abs(real);
- double b = Math.abs(imaginary);
+ final double a = Math.abs(real);
+ final double b = Math.abs(imaginary);
// (1 + (a + b i)) / (1 - (a + b i))
- Complex result = divide(1 + a, b, 1 - a, -b);
- // Compute the log here to avoid: result = result.log()
- a = Math.log(result.abs());
- b = result.getArgument();
+ final Complex result = divide(1 + a, b, 1 - a, -b);
+ // Compute the rest inline to avoid Complex object creation.
+ final double re = Math.log(result.abs());
+ final double im = result.getArgument();
// Map back to the correct domain and divide by 2
- return constructor.create(Math.copySign(a * 0.5, real),
- Math.copySign(b * 0.5, imaginary));
+ return constructor.create(Math.copySign(re * 0.5, real),
+ Math.copySign(im * 0.5, imaginary));
}
if (Double.isInfinite(imaginary)) {
return constructor.create(Math.copySign(0, real), Math.copySign(PI_OVER_2, imaginary));
@@ -1284,6 +1287,7 @@ public final class Complex implements Serializable {
if (Double.isNaN(imaginary) && Double.isFinite(real)) {
return NAN;
}
+ // TODO - use the static acos function
final Complex result = acos();
// Set the sign appropriately for C99 equalities.
return (negative(result.imaginary)) ? result.multiplyByI() : result.multiplyByNegI();
@@ -1659,6 +1663,29 @@ public final class Complex implements Serializable {
* @return the square root of {@code this}.
*/
public Complex sqrt() {
+ return sqrt(real, imaginary);
+ }
+
+ /**
+ * Compute the square root of the complex number.
+ * Implements the following algorithm to compute {@code sqrt(a + b i)}:
+ * <ol>
+ * <li>Let {@code t = sqrt((|a| + |a + b i|) / 2)}
+ * <li>if {@code (a >= 0)} return {@code t + (b / 2t) i}
+ * <li>else return {@code |b| / 2t + sign(b)t i }
+ * </ol>
+ * where:
+ * <ul>
+ * <li>{@code |a| = }{@link Math#abs}(a)
+ * <li>{@code |a + b i| = }{@link Complex#abs}(a + b i)
+ * <li>{@code sign(b) = }{@link Math#copySign(double,double) copySign(1.0, b)}
+ * </ul>
+ *
+ * @param real Real component.
+ * @param imaginary Imaginary component.
+ * @return the square root of the complex number.
+ */
+ private static Complex sqrt(double real, double imaginary) {
// Special case for infinite imaginary for all real including nan
if (Double.isInfinite(imaginary)) {
return new Complex(Double.POSITIVE_INFINITY, imaginary);
@@ -1669,7 +1696,7 @@ public final class Complex implements Serializable {
if (real == 0 && imaginary == 0) {
return new Complex(0, imaginary);
}
- final double t = Math.sqrt((Math.abs(real) + abs()) / 2);
+ final double t = Math.sqrt((Math.abs(real) + Math.hypot(real, imaginary)) / 2);
if (real >= 0) {
return new Complex(t, imaginary / (2 * t));
}
@@ -1796,8 +1823,7 @@ public final class Complex implements Serializable {
* @see Math#atan2(double, double)
*/
public double getArgument() {
- // Delegate
- return Math.atan2(imaginary, real);
+ return getArgument(real, imaginary);
}
/**
@@ -1808,7 +1834,19 @@ public final class Complex implements Serializable {
* @see #getArgument()
*/
public double arg() {
- return getArgument();
+ return getArgument(real, imaginary);
+ }
+
+ /**
+ * Compute the argument of the complex number.
+ *
+ * @param real Real part.
+ * @param imaginary Imaginary part.
+ * @return the argument
+ */
+ private static double getArgument(double real, double imaginary) {
+ // Delegate
+ return Math.atan2(imaginary, real);
}
/**
@@ -1913,23 +1951,6 @@ public final class Complex implements Serializable {
}
/**
- * Create the conjugate of a complex number given the real and imaginary parts.
- * This is used in functions that implement conjugate identities. It is the functional
- * equivalent of:
- *
- * <pre>
- * z = new Complex(real, imaginary).conjugate();
- * </pre>
- *
- * @param real Real part.
- * @param imaginary Imaginary part.
- * @return {@code Complex} object
- */
- private static Complex ofCartesianConjugate(double real, double imaginary) {
- return new Complex(real, -imaginary);
- }
-
- /**
* Creates an exception.
*
* @param message Message prefix.
[commons-numbers] 01/19: Fix acosh (-0,0) specification.
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 6d2869f9033e9562c9c976a723bdebe20ace476d
Author: aherbert <ah...@apache.org>
AuthorDate: Fri Dec 6 10:59:28 2019 +0000
Fix acosh (-0,0) specification.
---
.../src/test/java/org/apache/commons/numbers/complex/CStandardTest.java | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
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 05b0b67..23321e2 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
@@ -826,7 +826,7 @@ public class CStandardTest {
final UnaryOperator<Complex> operation = Complex::acosh;
assertConjugateEquality(operation);
assertComplex(Complex.ZERO, operation, zeroPiTwo);
- assertComplex(negZeroZero, operation, negZeroPiTwo);
+ assertComplex(negZeroZero, operation, zeroPiTwo);
for (double x : finite) {
assertComplex(complex(x, inf), operation, infPiTwo);
}
[commons-numbers] 03/19: Update javadoc formulas to be consistent
with their Wolfram reference.
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 9181f7d94ddebcb0d651b2021a73ebb2f734938a
Author: aherbert <ah...@apache.org>
AuthorDate: Fri Dec 6 13:06:26 2019 +0000
Update javadoc formulas to be consistent with their Wolfram reference.
---
.../apache/commons/numbers/complex/Complex.java | 202 +++++++++++----------
1 file changed, 111 insertions(+), 91 deletions(-)
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 443b14a..6e3f4fd 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
@@ -295,13 +295,14 @@ public final class Complex implements Serializable {
/**
* Returns a {@code Complex} whose value is
* {@code (this + addend)}.
- * Uses the definitional formula
+ * Implements the formula:
* <pre>
- * (a + bi) + (c + di) = (a+c) + (b+d)i
+ * (a + b i) + (c + d i) = (a + c) + i (b + d)
* </pre>
*
* @param addend Value to be added to this {@code Complex}.
* @return {@code this + addend}.
+ * @see <a href="http://mathworld.wolfram.com/ComplexAddition.html">Complex Addition</a>
*/
public Complex add(Complex addend) {
return new Complex(real + addend.real,
@@ -321,10 +322,16 @@ public final class Complex implements Serializable {
}
/**
- * Returns the conjugate of this complex number.
- * The conjugate of {@code a + bi} is {@code a - bi}.
+ * Returns the
+ * <a href="http://mathworld.wolfram.com/ComplexConjugate.html">conjugate</a>
+ * z̅ of this complex number z.
+ * <pre>
+ * z = a + b i
*
- * @return the conjugate of this complex object.
+ * z̅ = a - b i
+ * </pre>
+ *
+ * @return the conjugate (z̅) of this complex object.
*/
public Complex conjugate() {
return new Complex(real, -imaginary);
@@ -344,12 +351,12 @@ public final class Complex implements Serializable {
/**
* Returns a {@code Complex} whose value is
* {@code (this / divisor)}.
- * Implements the definitional formula
+ * Implements the formula:
* <pre>
* <code>
- * a + bi ac + bd + (bc - ad)i
- * ------ = --------------------
- * c + di c<sup>2</sup> + d<sup>2</sup>
+ * a + b i ac + bd + i (bc - ad)
+ * ------- = ---------------------
+ * c + d i c<sup>2</sup> + d<sup>2</sup>
* </code>
* </pre>
*
@@ -359,6 +366,7 @@ public final class Complex implements Serializable {
*
* @param divisor Value by which this {@code Complex} is to be divided.
* @return {@code this / divisor}.
+ * @see <a href="http://mathworld.wolfram.com/ComplexDivision.html">Complex Division</a>
*/
public Complex divide(Complex divisor) {
double a = real;
@@ -454,6 +462,10 @@ public final class Complex implements Serializable {
/**
* Returns a {@code Complex} whose value is {@code (this / divisor)},
* with {@code divisor} interpreted as a real number.
+ * Implements the formula:
+ * <pre>
+ * (a + b i) / c = (a + b i) / (c + 0 i)
+ * </pre>
*
* @param divisor Value by which this {@code Complex} is to be divided.
* @return {@code this / divisor}.
@@ -472,7 +484,7 @@ public final class Complex implements Serializable {
public Complex reciprocal() {
if (Math.abs(real) < Math.abs(imaginary)) {
final double q = real / imaginary;
- final double scale = 1. / (real * q + imaginary);
+ final double scale = 1.0 / (real * q + imaginary);
double scaleQ = 0;
if (q != 0 &&
scale != 0) {
@@ -481,7 +493,7 @@ public final class Complex implements Serializable {
return new Complex(scaleQ, -scale);
}
final double q = imaginary / real;
- final double scale = 1. / (imaginary * q + real);
+ final double scale = 1.0 / (imaginary * q + real);
double scaleQ = 0;
if (q != 0 &&
scale != 0) {
@@ -640,7 +652,7 @@ public final class Complex implements Serializable {
* <p>The behavior is the same as if the components of the complex number were passed
* to {@link java.util.Arrays#hashCode(double[]) Arrays.hashCode(double[])}:
* <pre>
- * {@code Arrays.hashCode(new double[]{getReal(), getImaginary()})}
+ * {@code Arrays.hashCode(new double[] {getReal(), getImaginary()})}
* </pre>
*
* @return a hash code value for this object.
@@ -664,9 +676,10 @@ public final class Complex implements Serializable {
* Access the imaginary part (C++ grammar).
*
* @return the imaginary part.
+ * @see #getImaginary()
*/
public double imag() {
- return imaginary;
+ return getImaginary();
}
/**
@@ -682,16 +695,17 @@ public final class Complex implements Serializable {
* Access the real part (C++ grammar).
*
* @return the real part.
+ * @see #getReal()
*/
public double real() {
- return real;
+ return getReal();
}
/**
* Returns a {@code Complex} whose value is {@code this * factor}.
- * Implements the definitional formula:
+ * Implements the formula:
* <pre>
- * (a + bi)(c + di) = (ac - bd) + (ad + bc)i
+ * (a + b i)(c + d i) = (ac - bd) + i (ad + bc)
* </pre>
*
* <p>Recalculates to recover infinities as specified in C.99
@@ -700,6 +714,7 @@ public final class Complex implements Serializable {
*
* @param factor value to be multiplied by this {@code Complex}.
* @return {@code this * factor}.
+ * @see <a href="http://mathworld.wolfram.com/ComplexMultiplication.html">Complex Muliplication</a>
*/
public Complex multiply(Complex factor) {
double a = real;
@@ -813,6 +828,11 @@ public final class Complex implements Serializable {
/**
* Returns a {@code Complex} whose value is {@code this * factor}, with {@code factor}
* interpreted as a integer number.
+ * Implements the formula:
+ * <pre>
+ * (a + b i) c = (a + b i)(c + 0 i)
+ * = ac + bc i
+ * </pre>
*
* @param factor value to be multiplied by this {@code Complex}.
* @return {@code this * factor}.
@@ -825,6 +845,11 @@ public final class Complex implements Serializable {
/**
* Returns a {@code Complex} whose value is {@code this * factor}, with {@code factor}
* interpreted as a real number.
+ * Implements the formula:
+ * <pre>
+ * (a + b i) c = (a + b i)(c + 0 i)
+ * = ac + bc i
+ * </pre>
*
* @param factor value to be multiplied by this {@code Complex}.
* @return {@code this * factor}.
@@ -846,13 +871,14 @@ public final class Complex implements Serializable {
/**
* Returns a {@code Complex} whose value is
* {@code (this - subtrahend)}.
- * Uses the definitional formula
- * <p>
- * {@code (a + bi) - (c + di) = (a-c) + (b-d)i}
- * </p>
+ * Implements the formula:
+ * <pre>
+ * (a + b i) - (c + d i) = (a - c) + i (b - d)
+ * </pre>
*
* @param subtrahend value to be subtracted from this {@code Complex}.
* @return {@code this - subtrahend}.
+ * @see <a href="http://mathworld.wolfram.com/ComplexSubtraction.html">Complex Subtraction</a>
*/
public Complex subtract(Complex subtrahend) {
return new Complex(real - subtrahend.real,
@@ -862,10 +888,14 @@ public final class Complex implements Serializable {
/**
* Returns a {@code Complex} whose value is
* {@code (minuend - this)}.
- * Uses the definitional formula
- * <p>
- * {@code a - (c + di) = (a-c) -di}
- * </p>
+ * Implements the formula:
+ * <pre>
+ * a - (c + d i) = (a - c) - d i
+ * </pre>
+ *
+ * <p>Note: This will produce a different result than using
+ * {@code Complex.ofCartesian(minuend, 0).subtract(z)} when the imaginary component is
+ * zero; in this method the sign of the zero is negated.
*
* @param minuend value that this {@code Complex} is to be subtracted from.
* @return {@code minuend - this}.
@@ -878,6 +908,10 @@ public final class Complex implements Serializable {
/**
* Returns a {@code Complex} whose value is
* {@code (this - subtrahend)}.
+ * Implements the formula:
+ * <pre>
+ * (a + b i) - c = (a - c) + b i
+ * </pre>
*
* @param subtrahend value to be subtracted from this {@code Complex}.
* @return {@code this - subtrahend}.
@@ -894,7 +928,7 @@ public final class Complex implements Serializable {
* Implements the formula:
* <pre>
* <code>
- * acos(z) = -i (log(z + i (sqrt(1 - z<sup>2</sup>))))
+ * acos(z) = -i (ln(z + i (sqrt(1 - z<sup>2</sup>))))
* </code>
* </pre>
*
@@ -918,7 +952,7 @@ public final class Complex implements Serializable {
z = this;
constructor = Complex::ofCartesian;
}
- return z.add(z.sqrt1z().multiplyByI()).log().multiplyByNegI(constructor);
+ return z.add(z.square().subtractFromReal(1).sqrt().multiplyByI()).log().multiplyByNegI(constructor);
}
if (Double.isInfinite(imaginary)) {
return new Complex(PI_OVER_2, Math.copySign(Double.POSITIVE_INFINITY, -imaginary));
@@ -954,7 +988,7 @@ public final class Complex implements Serializable {
* inverse sine</a> of this complex number.
* <pre>
* <code>
- * asin(z) = -i (log(sqrt(1 - z<sup>2</sup>) + iz))
+ * asin(z) = -i (ln(iz + sqrt(1 - z<sup>2</sup>)))
* </code>
* </pre>
*
@@ -975,9 +1009,8 @@ public final class Complex implements Serializable {
* Compute the
* <a href="http://mathworld.wolfram.com/InverseTangent.html">
* inverse tangent</a> of this complex number.
- * Implements the formula:
* <pre>
- * atan(z) = (i/2) log((i + z)/(i - z))
+ * atan(z) = (i / 2) ln((i + z) / (i - z))
* </pre>
*
* <p>As per the C.99 standard this function is computed using the trigonomic identity:</p>
@@ -1027,7 +1060,9 @@ public final class Complex implements Serializable {
* inverse hyperbolic sine</a> of this complex number.
* Implements the formula:
* <pre>
- * asinh(z) = log(z+sqrt(z^2+1))
+ * <code>
+ * asinh(z) = ln(z + sqrt(1 + z<sup>2</sup>))
+ * </code>
* </pre>
*
* @return the inverse hyperbolic sine of this complex number
@@ -1081,7 +1116,7 @@ public final class Complex implements Serializable {
* inverse hyperbolic tangent</a> of this complex number.
* Implements the formula:
* <pre>
- * atanh(z) = log((1+z)/(1-z))/2
+ * atanh(z) = (1/2) ln((1 + z) / (1 - z))
* </pre>
*
* @return the inverse hyperbolic tangent of this complex number
@@ -1135,7 +1170,7 @@ public final class Complex implements Serializable {
* <a href="http://mathworld.wolfram.com/InverseHyperbolicCosine.html">
* inverse hyperbolic cosine</a> of this complex number.
* <pre>
- * acosh(z) = ln(z + sqrt(z + 1) * sqrt(z - 1))
+ * acosh(z) = ln(z + sqrt(z + 1) sqrt(z - 1))
* </pre>
*
* <p>This function is computed using the trigonomic identity:</p>
@@ -1177,11 +1212,8 @@ public final class Complex implements Serializable {
* cosine</a> of this complex number.
* Implements the formula:
* <pre>
- * cos(a + bi) = cos(a)cosh(b) - sin(a)sinh(b)i}
+ * cos(a + b i) = cos(a)*cosh(b) - i sin(a)*sinh(b)
* </pre>
- * where the (real) functions on the right-hand side are
- * {@link Math#sin}, {@link Math#cos},
- * {@link Math#cosh} and {@link Math#sinh}.
*
* <p>As per the C.99 standard this function is computed using the trigonomic identity:</p>
* <pre>
@@ -1203,11 +1235,8 @@ public final class Complex implements Serializable {
* hyperbolic cosine</a> of this complex number.
* Implements the formula:
* <pre>
- * cosh(a + bi) = cosh(a)cos(b) + sinh(a)sin(b)i
+ * cosh(a + b i) = cosh(a)cos(b) + i sinh(a)sin(b)
* </pre>
- * where the (real) functions on the right-hand side are
- * {@link Math#sin}, {@link Math#cos},
- * {@link Math#cosh} and {@link Math#sinh}.
*
* @return the hyperbolic cosine of this complex number.
*/
@@ -1277,11 +1306,8 @@ public final class Complex implements Serializable {
* exponential function</a> of this complex number.
* Implements the formula:
* <pre>
- * exp(a + bi) = exp(a)cos(b) + exp(a)sin(b)i
+ * exp(a + b i) = exp(a) (cos(b) + i sin(b))
* </pre>
- * where the (real) functions on the right-hand side are
- * {@link Math#exp}, {@link Math#cos}, and
- * {@link Math#sin}.
*
* @return <code><i>e</i><sup>this</sup></code>.
*/
@@ -1336,18 +1362,18 @@ public final class Complex implements Serializable {
* natural logarithm</a> of this complex number.
* Implements the formula:
* <pre>
- * log(a + bi) = ln(|a + bi|) + arg(a + bi)i
+ * ln(a + b i) = ln(|a + b i|) + i arg(a + b i)
* </pre>
- * where ln on the right hand side is {@link Math#log},
- * {@code |a + bi|} is the modulus, {@link Complex#abs}, and
- * {@code arg(a + bi) = }{@link Math#atan2}(b, a).
*
* @return the natural logarithm of {@code this}.
+ * @see Math#log(double)
+ * @see #abs()
+ * @see #arg()
*/
public Complex log() {
// All edge cases satisfied by the Math library
return new Complex(Math.log(abs()),
- Math.atan2(imaginary, real));
+ getArgument());
}
/**
@@ -1356,13 +1382,13 @@ public final class Complex implements Serializable {
* common logarithm</a> of this complex number.
* Implements the formula:
* <pre>
- * log10(a + bi) = log(|a + bi|) + arg(a + bi)i
+ * log10(a + bi) = log10(|a + b i|) + i arg(a + b i)
* </pre>
- * where log on the right hand side is {@link Math#log10},
- * {@code |a + bi|} is the modulus, {@link Complex#abs}, and
- * {@code arg(a + bi) = }{@link Math#atan2}(b, a).
*
* @return the base 10 logarithm of {@code this}.
+ * @see Math#log10(double)
+ * @see #abs()
+ * @see #arg()
*/
public Complex log10() {
// All edge cases satisfied by the Math library
@@ -1378,8 +1404,10 @@ public final class Complex implements Serializable {
* y<sup>x</sup> = exp(x·log(y))
* </code>
* </pre>
- * where {@code exp} and {@code log} are {@link #exp} and
- * {@link #log}, respectively.
+ *
+ * <p>If this Complex is zero then this method returns zero if {@code x} is positive
+ * in the real component and zero in the imaginary component;
+ * otherwise it returns (NaN + i NaN).
*
* @param x exponent to which this {@code Complex} is to be raised.
* @return <code>this<sup>x</sup></code>.
@@ -1401,6 +1429,15 @@ public final class Complex implements Serializable {
/**
* Returns of value of this complex number raised to the power of {@code x}.
+ * Implements the formula:
+ * <pre>
+ * <code>
+ * y<sup>x</sup> = exp(x·log(y))
+ * </code>
+ * </pre>
+ *
+ * <p>If this Complex is zero then this method returns zero if {@code x} is positive;
+ * otherwise it returns (NaN + i NaN).
*
* @param x exponent to which this {@code Complex} is to be raised.
* @return <code>this<sup>x</sup></code>.
@@ -1423,15 +1460,11 @@ public final class Complex implements Serializable {
/**
* Compute the
* <a href="http://mathworld.wolfram.com/Sine.html">
- * sine</a>
- * of this complex number.
+ * sine</a> of this complex number.
* Implements the formula:
* <pre>
- * sin(a + bi) = sin(a)cosh(b) - cos(a)sinh(b)i
+ * sin(a + b i) = sin(a)cosh(b) - i cos(a)sinh(b)
* </pre>
- * where the (real) functions on the right-hand side are
- * {@link Math#sin}, {@link Math#cos},
- * {@link Math#cosh} and {@link Math#sinh}.
*
* <p>As per the C.99 standard this function is computed using the trigonomic identity:</p>
* <pre>
@@ -1453,7 +1486,7 @@ public final class Complex implements Serializable {
* hyperbolic sine</a> of this complex number.
* Implements the formula:
* <pre>
- * sinh(a + bi) = sinh(a)cos(b)) + cosh(a)sin(b)i
+ * sinh(a + b i) = sinh(a)cos(b)) + i cosh(a)sin(b)
* </pre>
* where the (real) functions on the right-hand side are
* {@link Math#sin}, {@link Math#cos},
@@ -1518,15 +1551,17 @@ public final class Complex implements Serializable {
* Compute the
* <a href="http://mathworld.wolfram.com/SquareRoot.html">
* square root</a> of this complex number.
- * Implements the following algorithm to compute {@code sqrt(a + bi)}:
- * <ol><li>Let {@code t = sqrt((|a| + |a + bi|) / 2)}</li>
- * <li><pre>if {@code a ≥ 0} return {@code t + (b/2t)i}
- * else return {@code |b|/2t + sign(b)t i }</pre></li>
+ * Implements the following algorithm to compute {@code sqrt(a + b i)}:
+ * <ol>
+ * <li>Let {@code t = sqrt((|a| + |a + b i|) / 2)}
+ * <li>if {@code (a >= 0)} return {@code t + (b / 2t) i}
+ * <li>else return {@code |b| / 2t + sign(b)t i }
* </ol>
- * where <ul>
- * <li>{@code |a| = }{@link Math#abs}(a)</li>
- * <li>{@code |a + bi| = }{@link Complex#abs}(a + bi)</li>
- * <li>{@code sign(b) = }{@link Math#copySign(double,double) copySign(1d, b)}
+ * where:
+ * <ul>
+ * <li>{@code |a| = }{@link Math#abs}(a)
+ * <li>{@code |a + b i| = }{@link Complex#abs}(a + b i)
+ * <li>{@code sign(b) = }{@link Math#copySign(double,double) copySign(1.0, b)}
* </ul>
*
* @return the square root of {@code this}.
@@ -1547,7 +1582,7 @@ public final class Complex implements Serializable {
return new Complex(t, imaginary / (2 * t));
}
return new Complex(Math.abs(imaginary) / (2 * t),
- Math.copySign(1d, imaginary) * t);
+ Math.copySign(1.0, imaginary) * t);
}
// Imaginary is nan
return NAN;
@@ -1567,27 +1602,12 @@ public final class Complex implements Serializable {
/**
* Compute the
- * <a href="http://mathworld.wolfram.com/SquareRoot.html">
- * square root</a> of <code>1 - this<sup>2</sup></code> for this complex
- * number.
- *
- * @return the square root of <code>1 - this<sup>2</sup></code>.
- */
- private Complex sqrt1z() {
- return square().subtractFromReal(1).sqrt();
- }
-
- /**
- * Compute the
* <a href="http://mathworld.wolfram.com/Tangent.html">
* tangent</a> of this complex number.
* Implements the formula:
* <pre>
- * tan(a + bi) = sin(2a)/(cos(2a)+cosh(2b)) + [sinh(2b)/(cos(2a)+cosh(2b))]i
+ * tan(a + b i) = sin(2a)/(cos(2a)+cosh(2b)) + i [sinh(2b)/(cos(2a)+cosh(2b))]
* </pre>
- * where the (real) functions on the right-hand side are
- * {@link Math#sin}, {@link Math#cos}, {@link Math#cosh} and
- * {@link Math#sinh}.
*
* <p>As per the C.99 standard this function is computed using the trigonomic identity:</p>
* <pre>
@@ -1609,7 +1629,7 @@ public final class Complex implements Serializable {
* hyperbolic tangent</a> of this complex number.
* Implements the formula:
* <pre>
- * tan(a + bi) = sinh(2a)/(cosh(2a)+cos(2b)) + [sin(2b)/(cosh(2a)+cos(2b))]i
+ * tan(a + b i) = sinh(2a)/(cosh(2a)+cos(2b)) + i [sin(2b)/(cosh(2a)+cos(2b))]
* </pre>
* where the (real) functions on the right-hand side are
* {@link Math#sin}, {@link Math#cos}, {@link Math#cosh} and
@@ -1675,13 +1695,13 @@ public final class Complex implements Serializable {
* negative imaginary parts.
*
* <p>If either real or imaginary part (or both) is NaN, NaN is returned.
- * Infinite parts are handled as {@code Math.atan2} handles them,
+ * Infinite parts are handled as {@linkplain Math#atan2} handles them,
* essentially treating finite parts as zero in the presence of an
* infinite coordinate and returning a multiple of pi/4 depending on
* the signs of the infinite parts.
- * See the javadoc for {@code Math.atan2} for full details.</p>
*
* @return the argument of {@code this}.
+ * @see Math#atan2(double, double)
*/
public double getArgument() {
// Delegate
@@ -1726,7 +1746,7 @@ public final class Complex implements Serializable {
final List<Complex> result = new ArrayList<>();
// nth root of abs -- faster / more accurate to use a solver here?
- final double nthRootOfAbs = Math.pow(abs(), 1d / n);
+ final double nthRootOfAbs = Math.pow(abs(), 1.0 / n);
// Compute nth roots of complex number with k = 0, 1, ... n-1
final double nthPhi = getArgument() / n;
[commons-numbers] 05/19: Remove redundant disabled test.
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 4f61050469d540dd67cd48f5b6b1e6fc5e7399e0
Author: aherbert <ah...@apache.org>
AuthorDate: Fri Dec 6 13:09:47 2019 +0000
Remove redundant disabled test.
---
.../test/java/org/apache/commons/numbers/complex/ComplexTest.java | 8 --------
1 file changed, 8 deletions(-)
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 b62a649..fdd0b68 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
@@ -1294,14 +1294,6 @@ public class ComplexTest {
}
@Test
- @Disabled("Required if not implemented in terms of tanh")
- public void testTan() {
- // Check the conditions on the imaginary component that create special results.
- TestUtils.assertEquals(Complex.ONE, Complex.ofCartesian(0, 25).tan(), 0);
- TestUtils.assertEquals(Complex.ofCartesian(0, -1), Complex.ofCartesian(0, -25).tan(), 0);
- }
-
- @Test
public void testAtanhEdgeConditions() {
// Hits the edge case when imaginary == 0 but real != 0 or 1
final Complex c = Complex.ofCartesian(2, 0).atanh();
[commons-numbers] 02/19: Implement acosh using acos.
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit f8089850302b35ce9d61f90a215bcee57b3120ec
Author: aherbert <ah...@apache.org>
AuthorDate: Fri Dec 6 11:23:20 2019 +0000
Implement acosh using acos.
---
.../apache/commons/numbers/complex/Complex.java | 55 +++++++---------------
1 file changed, 18 insertions(+), 37 deletions(-)
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 55cbab4..443b14a 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
@@ -1134,51 +1134,32 @@ public final class Complex implements Serializable {
* Compute the
* <a href="http://mathworld.wolfram.com/InverseHyperbolicCosine.html">
* inverse hyperbolic cosine</a> of this complex number.
- * Implements the formula:
* <pre>
- * acosh(z) = log(z+sqrt(z^2-1))
+ * acosh(z) = ln(z + sqrt(z + 1) * sqrt(z - 1))
+ * </pre>
+ *
+ * <p>This function is computed using the trigonomic identity:</p>
+ * <pre>
+ * acosh(z) = +-i acos(z)
* </pre>
*
+ * <p>The sign of the multiplier is chosen to give {@code z.acosh().real() >= 0}
+ * and compatibility with the C.99 standard.</p>
+ *
* @return the inverse hyperbolic cosine of this complex number
*/
public Complex acosh() {
- if (Double.isFinite(real)) {
- if (Double.isFinite(imaginary)) {
- // Special case for zero
- if (real == 0 && imaginary == 0) {
- return new Complex(real, Math.copySign(PI_OVER_2, imaginary));
- }
- // ISO C99: Preserve the equality
- // acosh(conj(z)) = conj(acosh(z))
- final UnaryOperator<Complex> g = mapImaginaryToPositiveDomain();
- final Complex z = g.apply(this);
- final Complex result = z.square().subtract(1).sqrt().add(z).log();
- return g.apply(result);
- }
- if (Double.isInfinite(imaginary)) {
- return new Complex(Double.POSITIVE_INFINITY, Math.copySign(PI_OVER_2, imaginary));
- }
- // imaginary is NaN
+ // Define in terms of acos
+ // acosh(z) = +-i acos(z)
+ // Handle special case:
+ // acos(+-0 + iNaN) = π/2 + iNaN
+ // acosh(x + iNaN) = NaN + iNaN for all finite x (including zero)
+ if (Double.isNaN(imaginary) && Double.isFinite(real)) {
return NAN;
}
- if (Double.isInfinite(real)) {
- if (Double.isFinite(imaginary)) {
- final double im = real == Double.NEGATIVE_INFINITY ? Math.PI : 0;
- return new Complex(Double.POSITIVE_INFINITY, Math.copySign(im, imaginary));
- }
- if (Double.isInfinite(imaginary)) {
- final double im = real == Double.NEGATIVE_INFINITY ? PI_3_OVER_4 : PI_OVER_4;
- return new Complex(Double.POSITIVE_INFINITY, Math.copySign(im, imaginary));
- }
- // imaginary is NaN
- return new Complex(Double.POSITIVE_INFINITY, Double.NaN);
- }
- // real is NaN
- if (Double.isInfinite(imaginary)) {
- return new Complex(Double.POSITIVE_INFINITY, Double.NaN);
- }
- // optionally raises the ‘‘invalid’’ floating-point exception, for finite y.
- return NAN;
+ final Complex result = acos();
+ // Set the sign appropriately for C99 equalities.
+ return (negative(result.imaginary)) ? result.multiplyByI() : result.multiplyByNegI();
}
/**
[commons-numbers] 08/19: Optimise identity atan() to avoid Complex
object creation.
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 3441694b8e85e1e2d7118937901aa7a3cc78cfc7
Author: aherbert <ah...@apache.org>
AuthorDate: Fri Dec 6 13:59:43 2019 +0000
Optimise identity atan() to avoid Complex object creation.
Extract divide to static method for use in atanh.
---
.../apache/commons/numbers/complex/Complex.java | 81 +++++++++++++++++-----
1 file changed, 62 insertions(+), 19 deletions(-)
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 816773e..a59fda5 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
@@ -382,10 +382,31 @@ public final class Complex implements Serializable {
* @see <a href="http://mathworld.wolfram.com/ComplexDivision.html">Complex Division</a>
*/
public Complex divide(Complex divisor) {
- double a = real;
- double b = imaginary;
- double c = divisor.getReal();
- double d = divisor.getImaginary();
+ return divide(real, imaginary, divisor.real, divisor.imaginary);
+ }
+
+ /**
+ * Returns a {@code Complex} whose value is:
+ * <pre>
+ * <code>
+ * a + b i ac + bd + i (bc - ad)
+ * ------- = ---------------------
+ * c + d i c<sup>2</sup> + d<sup>2</sup>
+ * </code>
+ * </pre>
+ *
+ * <p>Recalculates to recover infinities as specified in C.99
+ * standard G.5.1. Method is fully in accordance with
+ * C++11 standards for complex numbers.</p>
+ *
+ * @param a Real component of first number.
+ * @param b Imaginary component of first number.
+ * @param c Real component of second number.
+ * @param d Imaginary component of second number.
+ * @return (a + b i) / (c + d i).
+ * @see <a href="http://mathworld.wolfram.com/ComplexDivision.html">Complex Division</a>
+ */
+ private static Complex divide(double a, double b, double c, double d) {
int ilogbw = 0;
final double logbw = Math.log(Math.max(Math.abs(c), Math.abs(d))) / Math.log(2);
if (Double.isFinite(logbw)) {
@@ -416,7 +437,7 @@ public final class Complex implements Serializable {
b = boxInfinity(b);
x = Double.POSITIVE_INFINITY * computeACplusBD(a, b, c, d);
y = Double.POSITIVE_INFINITY * computeBCminusAD(a, b, c, d);
- } else if (divisor.isInfinite() &&
+ } else if ((Double.isInfinite(c) || Double.isInfinite(d)) &&
Double.isFinite(a) && Double.isFinite(b)) {
// finite/infinite
c = boxInfinity(c);
@@ -1054,7 +1075,8 @@ public final class Complex implements Serializable {
public Complex atan() {
// Define in terms of atanh
// atan(z) = -i atanh(iz)
- return multiplyByI().atanh().multiplyByNegI();
+ // Multiply this number by I, compute atanh, then multiply by back
+ return atanh(-imaginary, real, Complex::multiplyNegativeI);
}
/**
@@ -1111,7 +1133,7 @@ public final class Complex implements Serializable {
* @param real Real part.
* @param imaginary Imaginary part.
* @param constructor Constructor.
- * @return the inverse hyperbolic sine of this complex number
+ * @return the inverse hyperbolic sine of the complex number
*/
private static Complex asinh(double real, double imaginary, ComplexConstructor constructor) {
if (Double.isFinite(real)) {
@@ -1172,44 +1194,65 @@ public final class Complex implements Serializable {
* @return the inverse hyperbolic tangent of this complex number
*/
public Complex atanh() {
+ return atanh(real, imaginary, Complex::ofCartesian);
+ }
+
+ /**
+ * Compute the inverse hyperbolic tangent of this complex number.
+ *
+ * <p>This function exists to allow implementation of the identity
+ * {@code sin(z) = -i sinh(iz)}.<p>
+ *
+ * @param real Real part.
+ * @param imaginary Imaginary part.
+ * @param constructor Constructor.
+ * @return the inverse hyperbolic tangent of the complex number
+ */
+ private static Complex atanh(double real, double imaginary, ComplexConstructor constructor) {
if (Double.isFinite(real)) {
if (Double.isFinite(imaginary)) {
// Special case for zero
if (imaginary == 0) {
if (real == 0) {
- return this;
+ return constructor.create(real, imaginary);
}
if (Math.abs(real) == 1) {
// raises the ‘‘divide-by-zero’’ floating-point exception.
- return new Complex(Math.copySign(Double.POSITIVE_INFINITY, real), imaginary);
+ return constructor.create(Math.copySign(Double.POSITIVE_INFINITY, real), imaginary);
}
}
// ISO C99: Preserve the equality
// atanh(conj(z)) = conj(atanh(z))
// and the odd function: f(z) = -f(-z)
// by always computing on a positive valued Complex number.
- final UnaryOperator<Complex> g = mapToPositiveDomain();
- final Complex z = g.apply(this);
- final Complex result = z.add(1).divide(z.subtractFromReal(1)).log().multiply(0.5);
- return g.apply(result);
+ double a = Math.abs(real);
+ double b = Math.abs(imaginary);
+ // (1 + (a + b i)) / (1 - (a + b i))
+ Complex result = divide(1 + a, b, 1 - a, -b);
+ // Compute the log here to avoid: result = result.log()
+ a = Math.log(result.abs());
+ b = result.getArgument();
+ // Map back to the correct domain and divide by 2
+ return constructor.create(Math.copySign(a * 0.5, real),
+ Math.copySign(b * 0.5, imaginary));
}
if (Double.isInfinite(imaginary)) {
- return new Complex(Math.copySign(0, real), Math.copySign(PI_OVER_2, imaginary));
+ return constructor.create(Math.copySign(0, real), Math.copySign(PI_OVER_2, imaginary));
}
// imaginary is NaN
// Special case for real == 0
- return real == 0 ? new Complex(real, Double.NaN) : NAN;
+ return real == 0 ? constructor.create(real, Double.NaN) : NAN;
}
if (Double.isInfinite(real)) {
if (Double.isNaN(imaginary)) {
- return new Complex(Math.copySign(0, real), Double.NaN);
+ return constructor.create(Math.copySign(0, real), Double.NaN);
}
// imaginary is finite or infinite
- return new Complex(Math.copySign(0, real), Math.copySign(PI_OVER_2, imaginary));
+ return constructor.create(Math.copySign(0, real), Math.copySign(PI_OVER_2, imaginary));
}
// real is NaN
if (Double.isInfinite(imaginary)) {
- return new Complex(0, Math.copySign(PI_OVER_2, imaginary));
+ return constructor.create(0, Math.copySign(PI_OVER_2, imaginary));
}
// optionally raises the ‘‘invalid’’ floating-point exception, for finite y.
return NAN;
@@ -1443,7 +1486,7 @@ public final class Complex implements Serializable {
public Complex log10() {
// All edge cases satisfied by the Math library
return new Complex(Math.log10(abs()),
- Math.atan2(imaginary, real));
+ getArgument());
}
/**
[commons-numbers] 04/19: Remove unused private method
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 4874158391c15e78c2905fba37414a2c428fe5e7
Author: aherbert <ah...@apache.org>
AuthorDate: Fri Dec 6 13:07:06 2019 +0000
Remove unused private method
---
.../apache/commons/numbers/complex/Complex.java | 33 ----------------------
1 file changed, 33 deletions(-)
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 6e3f4fd..e239471 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
@@ -1901,39 +1901,6 @@ public final class Complex implements Serializable {
}
/**
- * Creates a function to transform this Complex into a Complex with positive imaginary
- * components. This is used to maintain the conjugate equality of a function
- * f(z) by always computing the result on positive valued input. Given:
- *
- * <pre>
- * conj(f(z)) = f(conj(z))
- * </pre>
- *
- * <p>The Complex can be transformed to the positive domain using the {@link #conjugate()}
- * function, the function f(z) computed and the result transformed back using the same
- * mapping function to the original domain.</p>
- *
- * <pre>
- * g(z) = mapImaginaryToPositiveDomain()
- * f(z) = g(f(g(z)))
- * </pre>
- *
- * <p>If the Complex is already in the correct domain then this returns an identify
- * function. The function will be computed as:</p>
- *
- * <pre>
- * imaginary g(z)
- * + identity
- * - conjugate
- * </pre>
- *
- * @return the function
- */
- private UnaryOperator<Complex> mapImaginaryToPositiveDomain() {
- return negative(imaginary) ? Complex::conjugate : Complex::identity;
- }
-
- /**
* Returns a {@code Complex} whose real value is negated.
*
* @return {@code Complex(-real, imaginary)}.
[commons-numbers] 14/19: Add a test for square()
Posted by ah...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit 89c907fb4e25d5851303863ea0b6b05cd4555920
Author: aherbert <ah...@apache.org>
AuthorDate: Fri Dec 6 16:16:43 2019 +0000
Add a test for square()
---
.../org/apache/commons/numbers/complex/ComplexTest.java | 15 +++++++++++++++
1 file changed, 15 insertions(+)
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 fdd0b68..8efd26d 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
@@ -1301,4 +1301,19 @@ public class ComplexTest {
Assertions.assertEquals(0.54930614433405489, c.getReal());
Assertions.assertEquals(1.5707963267948966, c.getImaginary());
}
+
+ @Test
+ public void testSquare() {
+ final UniformRandomProvider rng = RandomSource.create(RandomSource.SPLIT_MIX_64);
+ final double min = -5;
+ final double range = -2 * min;
+ for (int i = 0; i < 10; i++) {
+ final Complex z = Complex.ofCartesian(min + range * rng.nextDouble(),
+ min + range * rng.nextDouble());
+ final Complex c1 = z.multiply(z);
+ final Complex c2 = z.square();
+ Assertions.assertEquals(c1.getReal(), c2.getReal(), "real");
+ Assertions.assertEquals(c1.getImaginary(), c2.getImaginary(), "imaginary");
+ }
+ }
}