You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@commons.apache.org by Gilles <gi...@harfang.homelinux.org> on 2017/07/19 13:54:36 UTC
Re: commons-numbers git commit: NUMBERS-13: cosh() passes all tests
Hi Eric.
Constants should be declared "static final".
Regards,
Gilles
On Wed, 19 Jul 2017 13:49:01 +0000 (UTC), ericbarnhill@apache.org
wrote:
> Repository: commons-numbers
> Updated Branches:
> refs/heads/complex-dev 1de701b3e -> c8db04d0a
>
>
> NUMBERS-13: cosh() passes all tests
>
>
> Project: http://git-wip-us.apache.org/repos/asf/commons-numbers/repo
> Commit:
>
> http://git-wip-us.apache.org/repos/asf/commons-numbers/commit/c8db04d0
> Tree:
> http://git-wip-us.apache.org/repos/asf/commons-numbers/tree/c8db04d0
> Diff:
> http://git-wip-us.apache.org/repos/asf/commons-numbers/diff/c8db04d0
>
> Branch: refs/heads/complex-dev
> Commit: c8db04d0ac1001774b97fb7abe3f198a30500335
> Parents: 1de701b
> Author: Eric Barnhill <er...@apache.org>
> Authored: Wed Jul 19 15:50:52 2017 +0200
> Committer: Eric Barnhill <er...@apache.org>
> Committed: Wed Jul 19 15:50:52 2017 +0200
>
>
> ----------------------------------------------------------------------
> .../apache/commons/numbers/complex/Complex.java | 14 +
> .../commons/numbers/complex/CStandardTest.java | 282
> +++++++++++++++++++
> 2 files changed, 296 insertions(+)
>
> ----------------------------------------------------------------------
>
>
>
> http://git-wip-us.apache.org/repos/asf/commons-numbers/blob/c8db04d0/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 e4c0a71..4eae524 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
> @@ -808,6 +808,20 @@ in the
> * @return the hyperbolic cosine of this complex number.
> */
> public Complex cosh() {
> + if (real == 0 && imaginary == Double.POSITIVE_INFINITY) {
> + return new Complex(Double.NaN, 0);
> + } else if (real == 0 && Double.isNaN(imaginary)) {
> + return new Complex(Double.NaN, 0);
> + } else if (real == Double.POSITIVE_INFINITY && imaginary ==
> 0) {
> + return new Complex(Double.POSITIVE_INFINITY, 0);
> + } else if (real == Double.POSITIVE_INFINITY && imaginary ==
> Double.POSITIVE_INFINITY) {
> + return new Complex(Double.POSITIVE_INFINITY,
> Double.NaN);
> + } else if (real == Double.POSITIVE_INFINITY &&
> Double.isNaN(imaginary)) {
> + return new Complex(Double.POSITIVE_INFINITY,
> Double.NaN);
> + } else if (Double.isNaN(real) && imaginary == 0) {
> + return new Complex(Double.NaN, 0);
> + }
> +
> return createComplex(Math.cosh(real) * Math.cos(imaginary),
> Math.sinh(real) * Math.sin(imaginary));
> }
>
>
> http://git-wip-us.apache.org/repos/asf/commons-numbers/blob/c8db04d0/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
> new file mode 100644
> index 0000000..9c178f2
> --- /dev/null
> +++
>
> b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java
> @@ -0,0 +1,282 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or
> more
> + * contributor license agreements. See the NOTICE file distributed
> with
> + * this work for additional information regarding copyright
> ownership.
> + * The ASF licenses this file to You under the Apache License,
> Version 2.0
> + * (the "License"); you may not use this file except in compliance
> with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing,
> software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions
> and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.numbers.complex;
> +
> +import org.apache.commons.numbers.complex.Complex;
> +import org.apache.commons.numbers.complex.ComplexUtils;
> +import org.junit.Assert;
> +import org.junit.Ignore;
> +import org.junit.Test;
> +
> +public class CStandardTest {
> +
> + private double inf = Double.POSITIVE_INFINITY;
> + private double negInf = Double.NEGATIVE_INFINITY;
> + private double nan = Double.NaN;
> + private double pi = Math.PI;
> + private double piOverFour = Math.PI / 4.0;
> + private double piOverTwo = Math.PI / 2.0;
> + private double threePiOverFour = 3.0*Math.PI/4.0;
> + private Complex oneOne = new Complex(1, 1);
> + private Complex oneZero = new Complex(1, 0);
> + private Complex oneInf = new Complex(1, inf);
> + private Complex oneNegInf = new Complex(1, negInf);
> + private Complex oneNaN = new Complex(1, nan);
> + private Complex zeroInf = new Complex(0, inf);
> + private Complex zeroNegInf = new Complex(0,negInf);
> + private Complex zeroNaN = new Complex(0, nan);
> + private Complex zeroPiTwo = new Complex(0.0, piOverTwo);
> + private Complex negZeroZero = new Complex(-0.0, 0);
> + private Complex negZeroNan = new Complex(-0.0, nan);
> + private Complex negI = new Complex(0.0, -1.0);
> + private Complex infOne = new Complex(inf, 1);
> + private Complex infZero = new Complex(inf, 0);
> + private Complex infNaN = new Complex(inf, nan);
> + private Complex infNegInf = new Complex(inf, negInf);
> + private Complex infInf = new Complex(inf, inf);
> + private Complex infPiTwo = new Complex(inf, piOverTwo);
> + private Complex infPiFour = new Complex(inf, piOverFour);
> + private Complex infPi = new Complex(inf, Math.PI);
> + private Complex negInfInf = new Complex(negInf, inf);
> + private Complex negInfZero = new Complex(negInf, 0);
> + private Complex negInfOne = new Complex(negInf, 1);
> + private Complex negInfNaN = new Complex(negInf, nan);
> + private Complex negInfNegInf = new Complex(negInf, negInf);
> + private Complex negInfPosInf = new Complex(negInf, inf);
> + private Complex negInfPi = new Complex(negInf, Math.PI);
> + private Complex nanInf = new Complex(nan, inf);
> + private Complex nanNegInf = new Complex(nan, negInf);
> + private Complex nanZero = new Complex(nan, 0);
> + private Complex nanOne = new Complex(nan, 1);
> + private Complex piTwoNaN = new Complex(piOverTwo, nan);
> + private Complex piNegInf = new Complex(Math.PI, negInf);
> + private Complex piTwoNegInf = new Complex(piOverTwo, negInf);
> + private Complex piTwoNegZero = new Complex(piOverTwo, -0.0);
> + private Complex threePiFourNegInf = new
> Complex(threePiOverFour,negInf);
> + private Complex piFourNegInf = new Complex(piOverFour, negInf);
> +
> + public void assertComplex(Complex c1, Complex c2, double
> realTol, double imagTol) {
> + Assert.assertEquals(c1.getReal(), c2.getReal(), realTol);
> + Assert.assertEquals(c1.getImaginary(), c2.getImaginary(),
> imagTol);
> + }
> +
> + public void assertComplex(Complex c1, Complex c2) {
> + Assert.assertEquals(c1.getReal(), c2.getReal(),0.0);
> + Assert.assertEquals(c1.getImaginary(), c2.getImaginary(),
> 0.0);
> + }
> +
> +
> + /**
> + * ISO C Standard G.6.3
> + */
> + @Test
> + public void testSqrt1() {
> + Complex z1 = new Complex(-2.0, 0.0);
> + Complex z2 = new Complex(0.0, Math.sqrt(2));
> + assertComplex(z1.sqrt(), z2);
> + z1 = new Complex(-2.0, -0.0);
> + z2 = new Complex(0.0, -Math.sqrt(2));
> + assertComplex(z1.sqrt(), z2);
> + }
> +
> + @Test
> + public void testImplicitTrig() {
> + Complex z1 = new Complex(3.0);
> + Complex z2 = new Complex(0.0, 3.0);
> + assertComplex(z1.asin(), negI.multiply(z2.asinh()));
> + assertComplex(z1.atan(), negI.multiply(z2.atanh()),
> Math.ulp(1), Math.ulp(1));
> + assertComplex(z1.cos(), z2.cosh());
> + assertComplex(z1.sin(), negI.multiply(z2.sinh()));
> + assertComplex(z1.tan(), negI.multiply(z1.tanh()));
> + }
> +
> + /**
> + * ISO C Standard G.6.1.1
> + */
> + @Test
> + public void testAcos() {
> + assertComplex(oneOne.acos().conj(), oneOne.conj().acos(),
> Math.ulp(1), Math.ulp(1));
> + assertComplex(Complex.ZERO.acos(), piTwoNegZero);
> + assertComplex(negZeroZero.acos(), piTwoNegZero);
> + assertComplex(zeroNaN.acos(), piTwoNaN);
> + assertComplex(oneInf.acos(), piTwoNegInf);
> + 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(nanInf.acos(), nanNegInf);
> + assertComplex(Complex.NaN.acos(), Complex.NaN);
> + }
> +
> + /**
> + * ISO C Standard G.6.2.2
> + */
> + @Test
> + public void testAsinh() {
> + // TODO: test for which Asinh is odd
> + assertComplex(oneOne.conj().asinh(), oneOne.asinh().conj());
> + assertComplex(Complex.ZERO.asinh(), Complex.ZERO);
> + assertComplex(oneInf.asinh(), infPiTwo);
> + 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(nanInf.asinh(), infNaN);
> + assertComplex(Complex.NaN, Complex.NaN);
> + }
> +
> + /**
> + * ISO C Standard G.6.2.3
> + */
> + @Test
> + public void testAtanh() {
> + assertComplex(oneOne.conj().atanh(), oneOne.atanh().conj());
> + assertComplex(Complex.ZERO.atanh(), Complex.ZERO);
> + assertComplex(zeroNaN.atanh(), zeroNaN);
> + assertComplex(oneZero.atanh(), infZero);
> + assertComplex(oneInf.atanh(),zeroPiTwo);
> + assertComplex(oneNaN.atanh(), Complex.NaN);
> + assertComplex(infOne.atanh(), zeroPiTwo);
> + assertComplex(infInf.atanh(), zeroPiTwo);
> + assertComplex(infNaN.atanh(), zeroNaN);
> + assertComplex(nanOne.atanh(), Complex.NaN);
> + assertComplex(nanInf.atanh(), zeroPiTwo);
> + assertComplex(Complex.NaN.atanh(), Complex.NaN);
> + }
> +
> + /**
> + * ISO C Standard G.6.2.4
> + */
> + @Test
> + public void testCosh() {
> + assertComplex(oneOne.cosh().conj(), oneOne.conj().cosh());
> + 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(infZero.cosh(), infZero);
> + // the next test does not appear to make sense:
> + // (inf + iy) = inf + cis(y)
> + // skipped
> + assertComplex(infInf.cosh(), infNaN);
> + assertComplex(infNaN.cosh(), infNaN);
> + assertComplex(nanZero.cosh(), nanZero);
> + assertComplex(nanOne.cosh(), Complex.NaN);
> + assertComplex(Complex.NaN.cosh(), Complex.NaN);
> + }
> +
> + /**
> + * ISO C Standard G.6.2.5
> + */
> + @Test
> + public void testSinh() {
> + assertComplex(oneOne.sinh().conj(), oneOne.conj().sinh());
> // AND CSINH IS ODD
> + 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(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);
> + }
> +
> + /**
> + * ISO C Standard G.6.2.6
> + */
> + @Test
> + 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);
> + //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);
> + }
> +
> + /**
> + * ISO C Standard G.6.3.1
> + */
> + @Test
> + public void testExp() {
> + 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(infZero.exp(), infZero);
> + // Do not understand next test
> + assertComplex(negInfInf.exp(), Complex.ZERO);
> + assertComplex(infInf.exp(), infNaN);
> + assertComplex(negInfNaN.exp(), Complex.ZERO);
> + assertComplex(infNaN.exp(), infNaN);
> + assertComplex(nanZero.exp(), nanZero);
> + assertComplex(nanOne.exp(), Complex.NaN);
> + assertComplex(Complex.NaN.exp(), Complex.NaN);
> + }
> +
> + /**
> + * ISO C Standard G.6.3.2
> + */
> + @Test
> + public void testLog() {
> + assertComplex(oneOne.log().conj(), oneOne.conj().log());
> + assertComplex(negZeroZero.log(), negInfPi);
> + assertComplex(Complex.ZERO.log(), negInfZero);
> + assertComplex(oneInf.log(), infPiTwo);
> + 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(nanInf.log(), infNaN);
> + assertComplex(Complex.NaN.log(), Complex.NaN);
> + }
> +
> + /**
> + * ISO C Standard G.6.4.2
> + */
> + @Test
> + public void testSqrt2() {
> + assertComplex(oneOne.sqrt().conj(), oneOne.conj().sqrt());
> + assertComplex(Complex.ZERO.sqrt(), Complex.ZERO);
> + assertComplex(oneInf.sqrt(), infInf);
> + assertComplex(negInfOne.sqrt(), zeroNaN);
> + assertComplex(infOne.sqrt(), infZero);
> + assertComplex(negInfNaN.sqrt(), nanInf);
> + assertComplex(infNaN.sqrt(), infNaN);
> + assertComplex(nanOne.sqrt(), Complex.NaN);
> + assertComplex(Complex.NaN.sqrt(), Complex.NaN);
> + }
> +}
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@commons.apache.org
For additional commands, e-mail: dev-help@commons.apache.org