commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Gilles <gil...@harfang.homelinux.org>
Subject Re: commons-numbers git commit: added new files
Date Fri, 28 Apr 2017 10:59:15 GMT
Hi Eric.

On Thu, 27 Apr 2017 22:47:46 +0000 (UTC), ericbarnhill@apache.org 
wrote:
> Repository: commons-numbers
> Updated Branches:
>   refs/heads/complex-dev 07bbda2fd -> 15136c2d6
>
>
> added new files


Spurious files (see below)?

>
> Project: http://git-wip-us.apache.org/repos/asf/commons-numbers/repo
> Commit:
> 
> http://git-wip-us.apache.org/repos/asf/commons-numbers/commit/15136c2d
> Tree: 
> http://git-wip-us.apache.org/repos/asf/commons-numbers/tree/15136c2d
> Diff: 
> http://git-wip-us.apache.org/repos/asf/commons-numbers/diff/15136c2d
>
> Branch: refs/heads/complex-dev
> Commit: 15136c2d6b6112ae6fa60c1eb644ce70f675b4c5
> Parents: 07bbda2
> Author: Eric Barnhill <ericbarnhill@apache.org>
> Authored: Fri Apr 28 00:47:26 2017 +0200
> Committer: Eric Barnhill <ericbarnhill@apache.org>
> Committed: Fri Apr 28 00:47:26 2017 +0200
>
> 
> ----------------------------------------------------------------------
>  .../commons/numbers/complex/.Complex.java.swo   |  Bin 0 -> 65536 
> bytes

?

>  .../commons/numbers/complex/Complex.java.orig   | 1320 
> ++++++++++++++++++

?

>  .../numbers/complex/.CStandardTest.java.swo     |  Bin 0 -> 28672 
> bytes

?


Regards,
Gilles

>  .../commons/numbers/complex/CStandardTest.java  |  265 ++++
>  4 files changed, 1585 insertions(+)
> 
> ----------------------------------------------------------------------
>
>
> 
> http://git-wip-us.apache.org/repos/asf/commons-numbers/blob/15136c2d/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/.Complex.java.swo
> 
> ----------------------------------------------------------------------
> diff --git
> 
> a/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/.Complex.java.swo
> 
> b/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/.Complex.java.swo
> new file mode 100644
> index 0000000..7720390
> Binary files /dev/null and
> 
> b/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/.Complex.java.swo
> differ
>
> 
> http://git-wip-us.apache.org/repos/asf/commons-numbers/blob/15136c2d/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/Complex.java.orig
> 
> ----------------------------------------------------------------------
> diff --git
> 
> a/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/Complex.java.orig
> 
> b/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/Complex.java.orig
> new file mode 100644
> index 0000000..d3c7ce0
> --- /dev/null
> +++
> 
> b/commons-numbers-complex/src/main/java/org/apache/commons/numbers/complex/Complex.java.orig
> @@ -0,0 +1,1320 @@
> +/*
> + * 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 java.io.Serializable;
> +import java.util.ArrayList;
> +import java.util.List;
> +import org.apache.commons.numbers.core.Precision;
> +/**
> + * Representation of a Complex number, i.e., a number which has both 
> a
> + * real and imaginary part.
> + * <p>
> + * Implementations of arithmetic operations handle {@code NaN} and
> + * infinite values according to the rules for {@link 
> java.lang.Double}, i.e.
> + * {@link #equals} is an equivalence relation for all instances that 
> have
> + * a {@code NaN} in either real or imaginary part, e.g. the 
> following are
> + * considered equal:
> + * <ul>
> + *  <li>{@code 1 + NaNi}</li>
> + *  <li>{@code NaN + i}</li>
> + *  <li>{@code NaN + NaNi}</li>
> + * </ul><p>
> + * Note that this contradicts the IEEE-754 standard for floating
> + * point numbers (according to which the test {@code x == x} must 
> fail if
> + * {@code x} is {@code NaN}). The method
> + * {@link
> org.apache.commons.numbers.core.Precision#equals(double,double,int)
> + * equals for primitive double} in class {@code Precision} conforms 
> with
> + * IEEE-754 while this class conforms with the standard behavior for 
> Java
> + * object types.</p>
> + *
> + */
> +public class Complex implements Serializable  {
> +    /** The square root of -1. A number representing "0.0 + 1.0i" */
> +    public static final Complex I = new Complex(0.0, 1.0);
> +    // CHECKSTYLE: stop ConstantName
> +    /** A complex number representing "NaN + NaNi" */
> +    public static final Complex NaN = new Complex(Double.NaN, 
> Double.NaN);
> +    // CHECKSTYLE: resume ConstantName
> +    /** A complex number representing "+INF + INFi" */
> +    public static final Complex INF = new
> Complex(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
> +    /** A complex number representing "1.0 + 0.0i" */
> +    public static final Complex ONE = new Complex(1.0, 0.0);
> +    /** A complex number representing "0.0 + 0.0i" */
> +    public static final Complex ZERO = new Complex(0.0, 0.0);
> +
> +    /** Serializable version identifier */
> +    private static final long serialVersionUID = 201701120L;
> +
> +    /** The imaginary part. */
> +    private final double imaginary;
> +    /** The real part. */
> +    private final double real;
> +    /** Record whether this complex number is equal to NaN. */
> +    private final transient boolean isNaN;
> +    /** Record whether this complex number is infinite. */
> +    private final transient boolean isInfinite;
> +
> +    /**
> +     * Create a complex number given only the real part.
> +     *
> +     * @param real Real part.
> +     */
> +    public Complex(double real) {
> +        this(real, 0.0);
> +    }
> +
> +    /**
> +     * Create a complex number given the real and imaginary parts.
> +     *
> +     * @param real Real part.
> +     * @param imaginary Imaginary part.
> +     */
> +    public Complex(double real, double imaginary) {
> +        this.real = real;
> +        this.imaginary = imaginary;
> +
> +        isNaN = Double.isNaN(real) || Double.isNaN(imaginary);
> +        isInfinite = !isNaN &&
> +            (Double.isInfinite(real) || 
> Double.isInfinite(imaginary));
> +    }
> +
> +    /**
> +     * Return the absolute value of this complex number.
> +     * Returns {@code NaN} if either real or imaginary part is 
> {@code NaN}
> +     * and {@code Double.POSITIVE_INFINITY} if neither part is 
> {@code NaN},
> +     * but at least one part is infinite.
> +     * This code follows the <a
> href="http://www.iso-9899.info/wiki/The_Standard">ISO C Standard</a>,
> Annex G, in calculating the returned value (i.e. the hypot(x,y)
> method)
> +     *
> +     * @return the absolute value.
> +     */
> +    public double abs() {
> +        if (isNaN) {
> +            return Double.NaN;
> +        }
> +        if (isInfinite()) {
> +            return Double.POSITIVE_INFINITY;
> +        }
> +        if (Math.abs(real) < Math.abs(imaginary)) {
> +            if (imaginary == 0.0) {
> +                return Math.abs(real);
> +            }
> +            double q = real / imaginary;
> +            return Math.abs(imaginary) * Math.sqrt(1 + q * q);
> +        } else {
> +            if (real == 0.0) {
> +                return Math.abs(imaginary);
> +            }
> +            double q = imaginary / real;
> +            return Math.abs(real) * Math.sqrt(1 + q * q);
> +        }
> +    }
> +
> +    /**
> +     * Returns a {@code Complex} whose value is
> +     * {@code (this + addend)}.
> +     * Uses the definitional formula
> +     * <p>
> +     *   {@code (a + bi) + (c + di) = (a+c) + (b+d)i}
> +     * </p>
> +     * If either {@code this} or {@code addend} has a {@code NaN} 
> value in
> +     * either part, {@link #NaN} is returned; otherwise {@code 
> Infinite}
> +     * and {@code NaN} values are returned in the parts of the 
> result
> +     * according to the rules for {@link java.lang.Double} 
> arithmetic.
> +     *
> +     * @param  addend Value to be added to this {@code Complex}.
> +     * @return {@code this + addend}.
> +     */
> +    public Complex add(Complex addend) {
> +        checkNotNull(addend);
> +        if (isNaN || addend.isNaN) {
> +            return NaN;
> +        }
> +
> +        return createComplex(real + addend.getReal(),
> +                             imaginary + addend.getImaginary());
> +    }
> +
> +    /**
> +     * Returns a {@code Complex} whose value is {@code (this + 
> addend)},
> +     * with {@code addend} interpreted as a real number.
> +     *
> +     * @param addend Value to be added to this {@code Complex}.
> +     * @return {@code this + addend}.
> +     * @see #add(Complex)
> +     */
> +    public Complex add(double addend) {
> +        if (isNaN || Double.isNaN(addend)) {
> +            return NaN;
> +        }
> +
> +        return createComplex(real + addend, imaginary);
> +    }
> +
> +     /**
> +     * Returns the conjugate of this complex number.
> +     * The conjugate of {@code a + bi} is {@code a - bi}.
> +     * <p>
> +     * {@link #NaN} is returned if either the real or imaginary
> +     * part of this Complex number equals {@code Double.NaN}.
> +     * </p><p>
> +     * If the imaginary part is infinite, and the real part is not
> +     * {@code NaN}, the returned value has infinite imaginary part
> +     * of the opposite sign, e.g. the conjugate of
> +     * {@code 1 + POSITIVE_INFINITY i} is {@code 1 - 
> NEGATIVE_INFINITY i}.
> +     * </p>
> +     * @return the conjugate of this Complex object.
> +     */
> +    public Complex conjugate() {
> +        if (isNaN) {
> +            return NaN;
> +        }
> +
> +        return createComplex(real, -imaginary);
> +    }
> +
> +    /**
> +     * Returns a {@code Complex} whose value is
> +     * {@code (this / divisor)}.
> +     * Implements the definitional formula
> +     * <pre>
> +     *  <code>
> +     *    a + bi          ac + bd + (bc - ad)i
> +     *    ----------- = -------------------------
> +     *    c + di         c<sup>2</sup> + d<sup>2</sup>
> +     *  </code>
> +     * </pre>
> +     * but uses
> +     * <a href="http://doi.acm.org/10.1145/1039813.1039814">
> +     * prescaling of operands</a> to limit the effects of overflows 
> and
> +     * underflows in the computation.
> +     * <p>
> +     * {@code Infinite} and {@code NaN} values are handled according 
> to the
> +     * following rules, applied in the order presented:
> +     * <ul>
> +     *  <li>If either {@code this} or {@code divisor} has a {@code
> NaN} value
> +     *   in either part, {@link #NaN} is returned.
> +     *  </li>
> +     *  <li>If {@code divisor} equals {@link #ZERO}, {@link #NaN} is
> returned.
> +     *  </li>
> +     *  <li>If {@code this} and {@code divisor} are both infinite,
> +     *   {@link #NaN} is returned.
> +     *  </li>
> +     *  <li>If {@code this} is finite (i.e., has no {@code Infinite} 
> or
> +     *   {@code NaN} parts) and {@code divisor} is infinite (one or
> both parts
> +     *   infinite), {@link #ZERO} is returned.
> +     *  </li>
> +     *  <li>If {@code this} is infinite and {@code divisor} is 
> finite,
> +     *   {@code NaN} values are returned in the parts of the result 
> if the
> +     *   {@link java.lang.Double} rules applied to the definitional 
> formula
> +     *   force {@code NaN} results.
> +     *  </li>
> +     * </ul>
> +     *
> +     * @param divisor Value by which this {@code Complex} is to be 
> divided.
> +     * @return {@code this / divisor}.
> +     */
> +    public Complex divide(Complex divisor) {
> +        checkNotNull(divisor);
> +        if (isNaN || divisor.isNaN) {
> +            return NaN;
> +        }
> +
> +        final double c = divisor.getReal();
> +        final double d = divisor.getImaginary();
> +        if (c == 0.0 && d == 0.0) {
> +            return NaN;
> +        }
> +
> +        if (divisor.isInfinite() && !isInfinite()) {
> +            return ZERO;
> +        }
> +
> +        if (Math.abs(c) < Math.abs(d)) {
> +            double q = c / d;
> +            double denominator = c * q + d;
> +            return createComplex((real * q + imaginary) / 
> denominator,
> +                (imaginary * q - real) / denominator);
> +        } else {
> +            double q = d / c;
> +            double denominator = d * q + c;
> +            return createComplex((imaginary * q + real) / 
> denominator,
> +                (imaginary - real * q) / denominator);
> +        }
> +    }
> +
> +    /**
> +     * Returns a {@code Complex} whose value is {@code (this / 
> divisor)},
> +     * with {@code divisor} interpreted as a real number.
> +     *
> +     * @param  divisor Value by which this {@code Complex} is to be 
> divided.
> +     * @return {@code this / divisor}.
> +     * @see #divide(Complex)
> +     */
> +    public Complex divide(double divisor) {
> +        if (isNaN || Double.isNaN(divisor)) {
> +            return NaN;
> +        }
> +        if (divisor == 0d) {
> +            return NaN;
> +        }
> +        if (Double.isInfinite(divisor)) {
> +            return !isInfinite() ? ZERO : NaN;
> +        }
> +        return createComplex(real / divisor,
> +                             imaginary  / divisor);
> +    }
> +
> +    /**
> +     * Returns the multiplicative inverse this instance.
> +     *
> +     * @return {@code 1 / this}.
> +     * @see #divide(Complex)
> +     */
> +    public Complex reciprocal() {
> +        if (isNaN) {
> +            return NaN;
> +        }
> +
> +        if (real == 0.0 && imaginary == 0.0) {
> +            return INF;
> +        }
> +
> +        if (isInfinite) {
> +            return ZERO;
> +        }
> +
> +        if (Math.abs(real) < Math.abs(imaginary)) {
> +            double q = real / imaginary;
> +            double scale = 1. / (real * q + imaginary);
> +            return createComplex(scale * q, -scale);
> +        } else {
> +            double q = imaginary / real;
> +            double scale = 1. / (imaginary * q + real);
> +            return createComplex(scale, -scale * q);
> +        }
> +    }
> +
> +    /**
> +     * Test for equality with another object.
> +     * If both the real and imaginary parts of two complex numbers
> +     * are exactly the same, and neither is {@code Double.NaN}, the 
> two
> +     * Complex objects are considered to be equal.
> +     * The behavior is the same as for JDK's {@link 
> Double#equals(Object)
> +     * Double}:
> +     * <ul>
> +     *  <li>All {@code NaN} values are considered to be equal,
> +     *   i.e, if either (or both) real and imaginary parts of the 
> complex
> +     *   number are equal to {@code Double.NaN}, the complex number 
> is equal
> +     *   to {@code NaN}.
> +     *  </li>
> +     *  <li>
> +     *   Instances constructed with different representations of 
> zero (i.e.
> +     *   either "0" or "-0") are <em>not</em> considered to be 
> equal.
> +     *  </li>
> +     * </ul>
> +     *
> +     * @param other Object to test for equality with this instance.
> +     * @return {@code true} if the objects are equal, {@code false}
> if object
> +     * is {@code null}, not an instance of {@code Complex}, or not 
> equal to
> +     * this instance.
> +     */
> +    @Override
> +    public boolean equals(Object other) {
> +        if (this == other) {
> +            return true;
> +        }
> +        if (other instanceof Complex){
> +            Complex c = (Complex) other;
> +            if (c.isNaN) {
> +                return isNaN;
> +            } else {
> +                return equals(real, c.real) &&
> +                    equals(imaginary, c.imaginary);
> +            }
> +        }
> +        return false;
> +    }
> +
> +    /**
> +     * Test for the floating-point equality between Complex objects.
> +     * It returns {@code true} if both arguments are equal or within 
> the
> +     * range of allowed error (inclusive).
> +     *
> +     * @param x First value (cannot be {@code null}).
> +     * @param y Second value (cannot be {@code null}).
> +     * @param maxUlps {@code (maxUlps - 1)} is the number of 
> floating point
> +     * values between the real (resp. imaginary) parts of {@code x} 
> and
> +     * {@code y}.
> +     * @return {@code true} if there are fewer than {@code maxUlps} 
> floating
> +     * point values between the real (resp. imaginary) parts of 
> {@code x}
> +     * and {@code y}.
> +     *
> +     * @see Precision#equals(double,double,int)
> +     */
> +    public static boolean equals(Complex x, Complex y, int maxUlps) 
> {
> +        return Precision.equals(x.real, y.real, maxUlps) &&
> +            Precision.equals(x.imaginary, y.imaginary, maxUlps);
> +    }
> +
> +    /**
> +     * Returns {@code true} iff the values are equal as defined by
> +     * {@link #equals(Complex,Complex,int) equals(x, y, 1)}.
> +     *
> +     * @param x First value (cannot be {@code null}).
> +     * @param y Second value (cannot be {@code null}).
> +     * @return {@code true} if the values are equal.
> +     */
> +    public static boolean equals(Complex x, Complex y) {
> +        return equals(x, y, 1);
> +    }
> +
> +    /**
> +     * Returns {@code true} if, both for the real part and for the 
> imaginary
> +     * part, there is no double value strictly between the arguments 
> or the
> +     * difference between them is within the range of allowed error
> +     * (inclusive).  Returns {@code false} if either of the
> arguments is NaN.
> +     *
> +     * @param x First value (cannot be {@code null}).
> +     * @param y Second value (cannot be {@code null}).
> +     * @param eps Amount of allowed absolute error.
> +     * @return {@code true} if the values are two adjacent floating 
> point
> +     * numbers or they are within range of each other.
> +     *
> +     * @see Precision#equals(double,double,double)
> +     */
> +    public static boolean equals(Complex x, Complex y, double eps) {
> +        return Precision.equals(x.real, y.real, eps) &&
> +            Precision.equals(x.imaginary, y.imaginary, eps);
> +    }
> +
> +    /**
> +     * Returns {@code true} if, both for the real part and for the 
> imaginary
> +     * part, there is no double value strictly between the arguments 
> or the
> +     * relative difference between them is smaller or equal to the 
> given
> +     * tolerance. Returns {@code false} if either of the arguments 
> is NaN.
> +     *
> +     * @param x First value (cannot be {@code null}).
> +     * @param y Second value (cannot be {@code null}).
> +     * @param eps Amount of allowed relative error.
> +     * @return {@code true} if the values are two adjacent floating 
> point
> +     * numbers or they are within range of each other.
> +     *
> +     * @see 
> Precision#equalsWithRelativeTolerance(double,double,double)
> +     */
> +    public static boolean equalsWithRelativeTolerance(Complex x, 
> Complex y,
> +                                                      double eps) {
> +        return Precision.equalsWithRelativeTolerance(x.real, y.real, 
> eps) &&
> +            Precision.equalsWithRelativeTolerance(x.imaginary,
> y.imaginary, eps);
> +    }
> +
> +    /**
> +     * Get a hashCode for the complex number.
> +     * Any {@code Double.NaN} value in real or imaginary part 
> produces
> +     * the same hash code {@code 7}.
> +     *
> +     * @return a hash code value for this object.
> +     */
> +    @Override
> +    public int hashCode() {
> +        if (isNaN) {
> +            return 7;
> +        }
> +<<<<<<< HEAD
> +        return 37 * 17 * (hash(imaginary) +
> +            hash(real));
> +    }
> +
> +    private int hash(double d) {
> +        final long v = Double.doubleToLongBits(d);
> +        return (int)(v^(v>>>32));
> +        //return new Double(d).hashCode();
> +=======
> +        return 37 * (17 * hash(imaginary) +
> +            hash(real));
> +>>>>>>> eb-test
> +    }
> +
> +    /**
> +     * Access the imaginary part.
> +     *
> +     * @return the imaginary part.
> +     */
> +    public double getImaginary() {
> +        return imaginary;
> +    }
> +
> +    /**
> +     * Access the real part.
> +     *
> +     * @return the real part.
> +     */
> +    public double getReal() {
> +        return real;
> +    }
> +
> +    /**
> +     * Checks whether either or both parts of this complex number is
> +     * {@code NaN}.
> +     *
> +     * @return true if either or both parts of this complex number 
> is
> +     * {@code NaN}; false otherwise.
> +     */
> +    public boolean isNaN() {
> +        return isNaN;
> +    }
> +
> +    /**
> +     * Checks whether either the real or imaginary part of this
> complex number
> +     * takes an infinite value (either {@code 
> Double.POSITIVE_INFINITY} or
> +     * {@code Double.NEGATIVE_INFINITY}) and neither part
> +     * is {@code NaN}.
> +     *
> +     * @return true if one or both parts of this complex number are 
> infinite
> +     * and neither part is {@code NaN}.
> +     */
> +    public boolean isInfinite() {
> +        return isInfinite;
> +    }
> +
> +    /**
> +     * Returns a {@code Complex} whose value is {@code this * 
> factor}.
> +     * Implements preliminary checks for {@code NaN} and infinity
> followed by
> +     * the definitional formula:
> +     * <p>
> +     *   {@code (a + bi)(c + di) = (ac - bd) + (ad + bc)i}
> +     * </p>
> +     * Returns {@link #NaN} if either {@code this} or {@code factor}
> has one or
> +     * more {@code NaN} parts.
> +     * <p>
> +     * Returns {@link #INF} if neither {@code this} nor {@code
> factor} has one
> +     * or more {@code NaN} parts and if either {@code this} or
> {@code factor}
> +     * has one or more infinite parts (same result is returned 
> regardless of
> +     * the sign of the components).
> +     * </p><p>
> +     * Returns finite values in components of the result per the
> definitional
> +     * formula in all remaining cases.</p>
> +     *
> +     * @param  factor value to be multiplied by this {@code 
> Complex}.
> +     * @return {@code this * factor}.
> +     */
> +    public Complex multiply(Complex factor) {
> +        checkNotNull(factor);
> +        if (isNaN || factor.isNaN) {
> +            return NaN;
> +        }
> +        if (Double.isInfinite(real) ||
> +            Double.isInfinite(imaginary) ||
> +            Double.isInfinite(factor.real) ||
> +            Double.isInfinite(factor.imaginary)) {
> +            // we don't use isInfinite() to avoid testing for NaN 
> again
> +            return INF;
> +        }
> +        return createComplex(real * factor.real - imaginary *
> factor.imaginary,
> +                             real * factor.imaginary + imaginary *
> factor.real);
> +    }
> +
> +    /**
> +     * Returns a {@code Complex} whose value is {@code this *
> factor}, with {@code factor}
> +     * interpreted as a integer number.
> +     *
> +     * @param  factor value to be multiplied by this {@code 
> Complex}.
> +     * @return {@code this * factor}.
> +     * @see #multiply(Complex)
> +     */
> +    public Complex multiply(final int factor) {
> +        if (isNaN) {
> +            return NaN;
> +        }
> +        if (Double.isInfinite(real) ||
> +            Double.isInfinite(imaginary)) {
> +            return INF;
> +        }
> +        return createComplex(real * factor, imaginary * factor);
> +    }
> +
> +    /**
> +     * Returns a {@code Complex} whose value is {@code this *
> factor}, with {@code factor}
> +     * interpreted as a real number.
> +     *
> +     * @param  factor value to be multiplied by this {@code 
> Complex}.
> +     * @return {@code this * factor}.
> +     * @see #multiply(Complex)
> +     */
> +    public Complex multiply(double factor) {
> +        if (isNaN || Double.isNaN(factor)) {
> +            return NaN;
> +        }
> +        if (Double.isInfinite(real) ||
> +            Double.isInfinite(imaginary) ||
> +            Double.isInfinite(factor)) {
> +            // we don't use isInfinite() to avoid testing for NaN 
> again
> +            return INF;
> +        }
> +        return createComplex(real * factor, imaginary * factor);
> +    }
> +
> +    /**
> +     * Returns a {@code Complex} whose value is {@code (-this)}.
> +     * Returns {@code NaN} if either real or imaginary
> +     * part of this Complex number is {@code Double.NaN}.
> +     *
> +     * @return {@code -this}.
> +     */
> +    public Complex negate() {
> +        if (isNaN) {
> +            return NaN;
> +        }
> +
> +        return createComplex(-real, -imaginary);
> +    }
> +
> +    /**
> +     * 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>
> +     * If either {@code this} or {@code subtrahend} has a {@code
> NaN]} value in either part,
> +     * {@link #NaN} is returned; otherwise infinite and {@code NaN}
> values are
> +     * returned in the parts of the result according to the rules 
> for
> +     * {@link java.lang.Double} arithmetic.
> +     *
> +     * @param  subtrahend value to be subtracted from this {@code 
> Complex}.
> +     * @return {@code this - subtrahend}.
> +     */
> +    public Complex subtract(Complex subtrahend) {
> +        checkNotNull(subtrahend);
> +        if (isNaN || subtrahend.isNaN) {
> +            return NaN;
> +        }
> +
> +        return createComplex(real - subtrahend.getReal(),
> +                             imaginary - subtrahend.getImaginary());
> +    }
> +
> +    /**
> +     * Returns a {@code Complex} whose value is
> +     * {@code (this - subtrahend)}.
> +     *
> +     * @param  subtrahend value to be subtracted from this {@code 
> Complex}.
> +     * @return {@code this - subtrahend}.
> +     * @see #subtract(Complex)
> +     */
> +    public Complex subtract(double subtrahend) {
> +        if (isNaN || Double.isNaN(subtrahend)) {
> +            return NaN;
> +        }
> +        return createComplex(real - subtrahend, imaginary);
> +    }
> +
> +    /**
> +     * Compute the
> +     * <a href="http://mathworld.wolfram.com/InverseCosine.html"
> TARGET="_top">
> +     * inverse cosine</a> of this complex number.
> +     * Implements the formula:
> +     * <p>
> +     *  {@code acos(z) = -i (log(z + i (sqrt(1 - z<sup>2</sup>))))}
> +     * </p>
> +     * Returns {@link Complex#NaN} if either real or imaginary part 
> of the
> +     * input argument is {@code NaN} or infinite.
> +     *
> +     * @return the inverse cosine of this complex number.
> +     */
> +    public Complex acos() {
> +        if (isNaN) {
> +            return NaN;
> +        }
> +
> +        return
> this.add(this.sqrt1z().multiply(I)).log().multiply(I.negate());
> +    }
> +
> +    /**
> +     * Compute the
> +     * <a href="http://mathworld.wolfram.com/InverseSine.html"
> TARGET="_top">
> +     * inverse sine</a> of this complex number.
> +     * Implements the formula:
> +     * <p>
> +     *  {@code asin(z) = -i (log(sqrt(1 - z<sup>2</sup>) + iz))}
> +     * </p><p>
> +     * Returns {@link Complex#NaN} if either real or imaginary part 
> of the
> +     * input argument is {@code NaN} or infinite.</p>
> +     *
> +     * @return the inverse sine of this complex number.
> +     */
> +    public Complex asin() {
> +        if (isNaN) {
> +            return NaN;
> +        }
> +
> +        return 
> sqrt1z().add(this.multiply(I)).log().multiply(I.negate());
> +    }
> +
> +    /**
> +     * Compute the
> +     * <a href="http://mathworld.wolfram.com/InverseTangent.html"
> TARGET="_top">
> +     * inverse tangent</a> of this complex number.
> +     * Implements the formula:
> +     * <p>
> +     * {@code atan(z) = (i/2) log((i + z)/(i - z))}
> +     * </p><p>
> +     * Returns {@link Complex#NaN} if either real or imaginary part 
> of the
> +     * input argument is {@code NaN} or infinite.</p>
> +     *
> +     * @return the inverse tangent of this complex number
> +     */
> +    public Complex atan() {
> +        if (isNaN) {
> +            return NaN;
> +        }
> +
> +        return this.add(I).divide(I.subtract(this)).log()
> +                .multiply(I.divide(createComplex(2.0, 0.0)));
> +    }
> +
> +    /**
> +     * Compute the
> +     * <a href="http://mathworld.wolfram.com/Cosine.html" 
> TARGET="_top">
> +     * cosine</a> of this complex number.
> +     * Implements the formula:
> +     * <p>
> +     *  {@code cos(a + bi) = cos(a)cosh(b) - sin(a)sinh(b)i}
> +     * </p><p>
> +     * where the (real) functions on the right-hand side are
> +     * {@link Math#sin}, {@link Math#cos},
> +     * {@link Math#cosh} and {@link Math#sinh}.
> +     * </p><p>
> +     * Returns {@link Complex#NaN} if either real or imaginary part 
> of the
> +     * input argument is {@code NaN}.
> +     * </p><p>
> +     * Infinite values in real or imaginary parts of the input may 
> result in
> +     * infinite or NaN values returned in parts of the result.</p>
> +     * <pre>
> +     *  Examples:
> +     *  <code>
> +     *   cos(1 &plusmn; INFINITY i) = 1 \u2213 INFINITY i
> +     *   cos(&plusmn;INFINITY + i) = NaN + NaN i
> +     *   cos(&plusmn;INFINITY &plusmn; INFINITY i) = NaN + NaN i
> +     *  </code>
> +     * </pre>
> +     *
> +     * @return the cosine of this complex number.
> +     */
> +    public Complex cos() {
> +        if (isNaN) {
> +            return NaN;
> +        }
> +
> +        return createComplex(Math.cos(real) * Math.cosh(imaginary),
> +                             -Math.sin(real) * 
> Math.sinh(imaginary));
> +    }
> +
> +    /**
> +     * Compute the
> +     * <a href="http://mathworld.wolfram.com/HyperbolicCosine.html"
> TARGET="_top">
> +     * hyperbolic cosine</a> of this complex number.
> +     * Implements the formula:
> +     * <pre>
> +     *  <code>
> +     *   cosh(a + bi) = cosh(a)cos(b) + sinh(a)sin(b)i
> +     *  </code>
> +     * </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>
> +     * Returns {@link Complex#NaN} if either real or imaginary part 
> of the
> +     * input argument is {@code NaN}.
> +     * </p>
> +     * Infinite values in real or imaginary parts of the input may 
> result in
> +     * infinite or NaN values returned in parts of the result.
> +     * <pre>
> +     *  Examples:
> +     *  <code>
> +     *   cosh(1 &plusmn; INFINITY i) = NaN + NaN i
> +     *   cosh(&plusmn;INFINITY + i) = INFINITY &plusmn; INFINITY i
> +     *   cosh(&plusmn;INFINITY &plusmn; INFINITY i) = NaN + NaN i
> +     *  </code>
> +     * </pre>
> +     *
> +     * @return the hyperbolic cosine of this complex number.
> +     */
> +    public Complex cosh() {
> +        if (isNaN) {
> +            return NaN;
> +        }
> +
> +        return createComplex(Math.cosh(real) * Math.cos(imaginary),
> +                             Math.sinh(real) * Math.sin(imaginary));
> +    }
> +
> +    /**
> +     * Compute the
> +     * <a
> href="http://mathworld.wolfram.com/ExponentialFunction.html"
> TARGET="_top">
> +     * exponential function</a> of this complex number.
> +     * Implements the formula:
> +     * <pre>
> +     *  <code>
> +     *   exp(a + bi) = exp(a)cos(b) + exp(a)sin(b)i
> +     *  </code>
> +     * </pre>
> +     * where the (real) functions on the right-hand side are
> +     * {@link Math#exp}, {@link Math#cos}, and
> +     * {@link Math#sin}.
> +     * <p>
> +     * Returns {@link Complex#NaN} if either real or imaginary part 
> of the
> +     * input argument is {@code NaN}.
> +     * </p>
> +     * Infinite values in real or imaginary parts of the input may 
> result in
> +     * infinite or NaN values returned in parts of the result.
> +     * <pre>
> +     *  Examples:
> +     *  <code>
> +     *   exp(1 &plusmn; INFINITY i) = NaN + NaN i
> +     *   exp(INFINITY + i) = INFINITY + INFINITY i
> +     *   exp(-INFINITY + i) = 0 + 0i
> +     *   exp(&plusmn;INFINITY &plusmn; INFINITY i) = NaN + NaN i
> +     *  </code>
> +     * </pre>
> +     *
> +     * @return <code><i>e</i><sup>this</sup></code>.
> +     */
> +    public Complex exp() {
> +        if (isNaN) {
> +            return NaN;
> +        }
> +
> +        double expReal = Math.exp(real);
> +        return createComplex(expReal *  Math.cos(imaginary),
> +                             expReal * Math.sin(imaginary));
> +    }
> +
> +    /**
> +     * Compute the
> +     * <a href="http://mathworld.wolfram.com/NaturalLogarithm.html"
> TARGET="_top">
> +     * natural logarithm</a> of this complex number.
> +     * Implements the formula:
> +     * <pre>
> +     *  <code>
> +     *   log(a + bi) = ln(|a + bi|) + arg(a + bi)i
> +     *  </code>
> +     * </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).
> +     * <p>
> +     * Returns {@link Complex#NaN} if either real or imaginary part 
> of the
> +     * input argument is {@code NaN}.
> +     * </p>
> +     * Infinite (or critical) values in real or imaginary parts of
> the input may
> +     * result in infinite or NaN values returned in parts of the 
> result.
> +     * <pre>
> +     *  Examples:
> +     *  <code>
> +     *   log(1 &plusmn; INFINITY i) = INFINITY &plusmn; (&pi;/2)i
> +     *   log(INFINITY + i) = INFINITY + 0i
> +     *   log(-INFINITY + i) = INFINITY + &pi;i
> +     *   log(INFINITY &plusmn; INFINITY i) = INFINITY &plusmn; 
> (&pi;/4)i
> +     *   log(-INFINITY &plusmn; INFINITY i) = INFINITY &plusmn; 
> (3&pi;/4)i
> +     *   log(0 + 0i) = -INFINITY + 0i
> +     *  </code>
> +     * </pre>
> +     *
> +     * @return the value <code>ln &nbsp; this</code>, the natural 
> logarithm
> +     * of {@code this}.
> +     */
> +    public Complex log() {
> +        if (isNaN) {
> +            return NaN;
> +        }
> +        return createComplex(Math.log(abs()),
> +                             Math.atan2(imaginary, real));
> +    }
> +
> +    /**
> +     * 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&middot;log(y))
> +     *  </code>
> +     * </pre>
> +     * where {@code exp} and {@code log} are {@link #exp} and
> +     * {@link #log}, respectively.
> +     * <p>
> +     * Returns {@link Complex#NaN} if either real or imaginary part 
> of the
> +     * input argument is {@code NaN} or infinite, or if {@code y}
> +     * equals {@link Complex#ZERO}.</p>
> +     *
> +     * @param  x exponent to which this {@code Complex} is to be 
> raised.
> +     * @return <code> this<sup>x</sup></code>.
> +     */
> +    public Complex pow(Complex x) {
> +        checkNotNull(x);
> +        if (real == 0 && imaginary == 0) {
> +            if (x.real > 0 && x.imaginary == 0) {
> +                // 0 raised to positive number is 0
> +                return ZERO;
> +            } else {
> +                // 0 raised to anything else is NaN
> +                return NaN;
> +            }
> +        }
> +        return this.log().multiply(x).exp();
> +    }
> +
> +    /**
> +     * Returns of value of this complex number raised to the power
> of {@code x}.
> +     *
> +     * @param  x exponent to which this {@code Complex} is to be 
> raised.
> +     * @return <code>this<sup>x</sup></code>.
> +     * @see #pow(Complex)
> +     */
> +     public Complex pow(double x) {
> +        if (real == 0 && imaginary == 0) {
> +            if (x > 0) {
> +                // 0 raised to positive number is 0
> +                return ZERO;
> +            } else {
> +                // 0 raised to anything else is NaN
> +                return NaN;
> +            }
> +        }
> +        return this.log().multiply(x).exp();
> +    }
> +
> +    /**
> +     * Compute the
> +     * <a href="http://mathworld.wolfram.com/Sine.html" 
> TARGET="_top">
> +     * sine</a>
> +     * of this complex number.
> +     * Implements the formula:
> +     * <pre>
> +     *  <code>
> +     *   sin(a + bi) = sin(a)cosh(b) - cos(a)sinh(b)i
> +     *  </code>
> +     * </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>
> +     * Returns {@link Complex#NaN} if either real or imaginary part 
> of the
> +     * input argument is {@code NaN}.
> +     * </p><p>
> +     * Infinite values in real or imaginary parts of the input may 
> result in
> +     * infinite or {@code NaN} values returned in parts of the 
> result.
> +     * <pre>
> +     *  Examples:
> +     *  <code>
> +     *   sin(1 &plusmn; INFINITY i) = 1 &plusmn; INFINITY i
> +     *   sin(&plusmn;INFINITY + i) = NaN + NaN i
> +     *   sin(&plusmn;INFINITY &plusmn; INFINITY i) = NaN + NaN i
> +     *  </code>
> +     * </pre>
> +     *
> +     * @return the sine of this complex number.
> +     */
> +    public Complex sin() {
> +        if (isNaN) {
> +            return NaN;
> +        }
> +
> +        return createComplex(Math.sin(real) * Math.cosh(imaginary),
> +                             Math.cos(real) * Math.sinh(imaginary));
> +    }
> +
> +    /**
> +     * Compute the
> +     * <a href="http://mathworld.wolfram.com/HyperbolicSine.html"
> TARGET="_top">
> +     * hyperbolic sine</a> of this complex number.
> +     * Implements the formula:
> +     * <pre>
> +     *  <code>
> +     *   sinh(a + bi) = sinh(a)cos(b)) + cosh(a)sin(b)i
> +     *  </code>
> +     * </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>
> +     * Returns {@link Complex#NaN} if either real or imaginary part 
> of the
> +     * input argument is {@code NaN}.
> +     * </p><p>
> +     * Infinite values in real or imaginary parts of the input may 
> result in
> +     * infinite or NaN values returned in parts of the result.
> +     * <pre>
> +     *  Examples:
> +     *  <code>
> +     *   sinh(1 &plusmn; INFINITY i) = NaN + NaN i
> +     *   sinh(&plusmn;INFINITY + i) = &plusmn; INFINITY + INFINITY i
> +     *   sinh(&plusmn;INFINITY &plusmn; INFINITY i) = NaN + NaN i
> +     *  </code>
> +     * </pre>
> +     *
> +     * @return the hyperbolic sine of {@code this}.
> +     */
> +    public Complex sinh() {
> +        if (isNaN) {
> +            return NaN;
> +        }
> +
> +        return createComplex(Math.sinh(real) * Math.cos(imaginary),
> +            Math.cosh(real) * Math.sin(imaginary));
> +    }
> +
> +    /**
> +     * Compute the
> +     * <a href="http://mathworld.wolfram.com/SquareRoot.html" 
> TARGET="_top">
> +     * 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 &#8805; 0} return {@code t + (b/2t)i}
> +     *  else return {@code |b|/2t + sign(b)t i }</pre></li>
> +     * </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)}
> +     * </ul>
> +     * <p>
> +     * Returns {@link Complex#NaN} if either real or imaginary part 
> of the
> +     * input argument is {@code NaN}.
> +     * </p>
> +     * Infinite values in real or imaginary parts of the input may 
> result in
> +     * infinite or NaN values returned in parts of the result.
> +     * <pre>
> +     *  Examples:
> +     *  <code>
> +     *   sqrt(1 &plusmn; INFINITY i) = INFINITY + NaN i
> +     *   sqrt(INFINITY + i) = INFINITY + 0i
> +     *   sqrt(-INFINITY + i) = 0 + INFINITY i
> +     *   sqrt(INFINITY &plusmn; INFINITY i) = INFINITY + NaN i
> +     *   sqrt(-INFINITY &plusmn; INFINITY i) = NaN &plusmn; INFINITY 
> i
> +     *  </code>
> +     * </pre>
> +     *
> +     * @return the square root of {@code this}.
> +     */
> +    public Complex sqrt() {
> +        if (isNaN) {
> +            return NaN;
> +        }
> +
> +        if (real == 0.0 && imaginary == 0.0) {
> +            return createComplex(0.0, 0.0);
> +        }
> +
> +        double t = Math.sqrt((Math.abs(real) + abs()) / 2.0);
> +        if (real >= 0.0) {
> +            return createComplex(t, imaginary / (2.0 * t));
> +        } else {
> +            return createComplex(Math.abs(imaginary) / (2.0 * t),
> +                                 Math.copySign(1d, imaginary) * t);
> +        }
> +    }
> +
> +    /**
> +     * Compute the
> +     * <a href="http://mathworld.wolfram.com/SquareRoot.html" 
> TARGET="_top">
> +     * square root</a> of <code>1 - this<sup>2</sup></code> for this 
> complex
> +     * number.
> +     * Computes the result directly as
> +     * {@code sqrt(ONE.subtract(z.multiply(z)))}.
> +     * <p>
> +     * Returns {@link Complex#NaN} if either real or imaginary part 
> of the
> +     * input argument is {@code NaN}.
> +     * </p>
> +     * Infinite values in real or imaginary parts of the input may 
> result in
> +     * infinite or NaN values returned in parts of the result.
> +     *
> +     * @return the square root of <code>1 - this<sup>2</sup></code>.
> +     */
> +    public Complex sqrt1z() {
> +        return createComplex(1.0, 
> 0.0).subtract(this.multiply(this)).sqrt();
> +    }
> +
> +    /**
> +     * Compute the
> +     * <a href="http://mathworld.wolfram.com/Tangent.html" 
> TARGET="_top">
> +     * tangent</a> of this complex number.
> +     * Implements the formula:
> +     * <pre>
> +     *  <code>
> +     *   tan(a + bi) = sin(2a)/(cos(2a)+cosh(2b)) +
> [sinh(2b)/(cos(2a)+cosh(2b))]i
> +     *  </code>
> +     * </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>
> +     * Returns {@link Complex#NaN} if either real or imaginary part 
> of the
> +     * input argument is {@code NaN}.
> +     * </p>
> +     * Infinite (or critical) values in real or imaginary parts of
> the input may
> +     * result in infinite or NaN values returned in parts of the 
> result.
> +     * <pre>
> +     *  Examples:
> +     *  <code>
> +     *   tan(a &plusmn; INFINITY i) = 0 &plusmn; i
> +     *   tan(&plusmn;INFINITY + bi) = NaN + NaN i
> +     *   tan(&plusmn;INFINITY &plusmn; INFINITY i) = NaN + NaN i
> +     *   tan(&plusmn;&pi;/2 + 0 i) = &plusmn;INFINITY + NaN i
> +     *  </code>
> +     * </pre>
> +     *
> +     * @return the tangent of {@code this}.
> +     */
> +    public Complex tan() {
> +        if (isNaN || Double.isInfinite(real)) {
> +            return NaN;
> +        }
> +        if (imaginary > 20.0) {
> +            return createComplex(0.0, 1.0);
> +        }
> +        if (imaginary < -20.0) {
> +            return createComplex(0.0, -1.0);
> +        }
> +
> +        double real2 = 2.0 * real;
> +        double imaginary2 = 2.0 * imaginary;
> +        double d = Math.cos(real2) + Math.cosh(imaginary2);
> +
> +        return createComplex(Math.sin(real2) / d,
> +                             Math.sinh(imaginary2) / d);
> +    }
> +
> +    /**
> +     * Compute the
> +     * <a href="http://mathworld.wolfram.com/HyperbolicTangent.html"
> TARGET="_top">
> +     * hyperbolic tangent</a> of this complex number.
> +     * Implements the formula:
> +     * <pre>
> +     *  <code>
> +     *   tan(a + bi) = sinh(2a)/(cosh(2a)+cos(2b)) +
> [sin(2b)/(cosh(2a)+cos(2b))]i
> +     *  </code>
> +     * </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>
> +     * Returns {@link Complex#NaN} if either real or imaginary part 
> of the
> +     * input argument is {@code NaN}.
> +     * </p>
> +     * Infinite values in real or imaginary parts of the input may 
> result in
> +     * infinite or NaN values returned in parts of the result.
> +     * <pre>
> +     *  Examples:
> +     *  <code>
> +     *   tanh(a &plusmn; INFINITY i) = NaN + NaN i
> +     *   tanh(&plusmn;INFINITY + bi) = &plusmn;1 + 0 i
> +     *   tanh(&plusmn;INFINITY &plusmn; INFINITY i) = NaN + NaN i
> +     *   tanh(0 + (&pi;/2)i) = NaN + INFINITY i
> +     *  </code>
> +     * </pre>
> +     *
> +     * @return the hyperbolic tangent of {@code this}.
> +     */
> +    public Complex tanh() {
> +        if (isNaN || Double.isInfinite(imaginary)) {
> +            return NaN;
> +        }
> +        if (real > 20.0) {
> +            return createComplex(1.0, 0.0);
> +        }
> +        if (real < -20.0) {
> +            return createComplex(-1.0, 0.0);
> +        }
> +        double real2 = 2.0 * real;
> +        double imaginary2 = 2.0 * imaginary;
> +        double d = Math.cosh(real2) + Math.cos(imaginary2);
> +
> +        return createComplex(Math.sinh(real2) / d,
> +                             Math.sin(imaginary2) / d);
> +    }
> +
> +
> +
> +    /**
> +     * Compute the argument of this complex number.
> +     * The argument is the angle phi between the positive real axis 
> and
> +     * the point representing this number in the complex plane.
> +     * The value returned is between -PI (not inclusive)
> +     * and PI (inclusive), with negative values returned for numbers 
> with
> +     * 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,
> +     * 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.
> +     *
> +     * @return the argument of {@code this}.
> +     */
> +    public double getArgument() {
> +        return Math.atan2(getImaginary(), getReal());
> +    }
> +
> +    /**
> +     * Computes the n-th roots of this complex number.
> +     * The nth roots are defined by the formula:
> +     * <pre>
> +     *  <code>
> +     *   z<sub>k</sub> = abs<sup>1/n</sup> (cos(phi + 2&pi;k/n) + i
> (sin(phi + 2&pi;k/n))
> +     *  </code>
> +     * </pre>
> +     * for <i>{@code k=0, 1, ..., n-1}</i>, where {@code abs} and
> {@code phi}
> +     * are respectively the {@link #abs() modulus} and
> +     * {@link #getArgument() argument} of this complex number.
> +     * <p>
> +     * If one or both parts of this complex number is NaN, a list 
> with just
> +     * one element, {@link #NaN} is returned.
> +     * if neither part is NaN, but at least one part is infinite, 
> the result
> +     * is a one-element list containing {@link #INF}.
> +     *
> +     * @param n Degree of root.
> +     * @return a List of all {@code n}-th roots of {@code this}.
> +     */
> +    public List<Complex> nthRoot(int n) {
> +
> +        if (n <= 0) {
> +            throw new RuntimeException("cannot compute nth root for
> null or negative n: {0}");
> +        }
> +
> +        final List<Complex> result = new ArrayList<Complex>();
> +
> +        if (isNaN) {
> +            result.add(NaN);
> +            return result;
> +        }
> +        if (isInfinite()) {
> +            result.add(INF);
> +            return result;
> +        }
> +
> +        // nth root of abs -- faster / more accurate to use a solver 
> here?
> +        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;
> +        final double slice = 2 * Math.PI / n;
> +        double innerPart = nthPhi;
> +        for (int k = 0; k < n ; k++) {
> +            // inner part
> +            final double realPart = nthRootOfAbs *  
> Math.cos(innerPart);
> +            final double imaginaryPart = nthRootOfAbs *
> Math.sin(innerPart);
> +            result.add(createComplex(realPart, imaginaryPart));
> +            innerPart += slice;
> +        }
> +
> +        return result;
> +    }
> +
> +    /**
> +     * Create a complex number given the real and imaginary parts.
> +     *
> +     * @param realPart Real part.
> +     * @param imaginaryPart Imaginary part.
> +     * @return a new complex number instance.
> +     * @see #valueOf(double, double)
> +     */
> +    protected Complex createComplex(double realPart,
> +                                    double imaginaryPart) {
> +        return new Complex(realPart, imaginaryPart);
> +    }
> +
> +    /**
> +     * Create a complex number given the real and imaginary parts.
> +     *
> +     * @param realPart Real part.
> +     * @param imaginaryPart Imaginary part.
> +     * @return a Complex instance.
> +     */
> +    public static Complex valueOf(double realPart,
> +                                  double imaginaryPart) {
> +        if (Double.isNaN(realPart) ||
> +            Double.isNaN(imaginaryPart)) {
> +            return NaN;
> +        }
> +        return new Complex(realPart, imaginaryPart);
> +    }
> +
> +    /**
> +     * Create a complex number given only the real part.
> +     *
> +     * @param realPart Real part.
> +     * @return a Complex instance.
> +     */
> +    public static Complex valueOf(double realPart) {
> +        if (Double.isNaN(realPart)) {
> +            return NaN;
> +        }
> +        return new Complex(realPart);
> +    }
> +
> +    /**
> +     * Resolve the transient fields in a deserialized Complex 
> Object.
> +     * Subclasses will need to override {@link #createComplex} to
> +     * deserialize properly.
> +     *
> +     * @return A Complex instance with all fields resolved.
> +     */
> +    protected final Object readResolve() {
> +        return createComplex(real, imaginary);
> +    }
> +
> +    /** {@inheritDoc} */
> +    @Override
> +    public String toString() {
> +        return "(" + real + ", " + imaginary + ")";
> +    }
> +
> +    /**
> +     * Checks that an object is not null.
> +     *
> +     * @param o Object to be checked.
> +     */
> +    private static void checkNotNull(Object o) {
> +        if (o == null) {
> +            throw new RuntimeException("Null Argument to Complex 
> Method");
> +        }
> +    }
> +
> +    /**
> +     * Returns {@code true} if the values are equal according to
> semantics of
> +     * {@link Double#equals(Object)}.
> +     *
> +     * @param x Value
> +     * @param y Value
> +     * @return {@code new Double(x).equals(new Double(y))}
> +     */
> +    private static boolean equals(double x, double y) {
> +        return new Double(x).equals(new Double(y));
> +    }
> +
> +    /**
> +     * Returns an integer hash code representing the given double 
> value.
> +     *
> +     * @param value the value to be hashed
> +     * @return the hash code
> +     */
> +    private static int hash(double value) {
> +        return new Double(value).hashCode();
> +    }
> +}
>
> 
> http://git-wip-us.apache.org/repos/asf/commons-numbers/blob/15136c2d/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/.CStandardTest.java.swo
> 
> ----------------------------------------------------------------------
> diff --git
> 
> a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/.CStandardTest.java.swo
> 
> b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/.CStandardTest.java.swo
> new file mode 100644
> index 0000000..430efd7
> Binary files /dev/null and
> 
> b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/.CStandardTest.java.swo
> differ
>
> 
> http://git-wip-us.apache.org/repos/asf/commons-numbers/blob/15136c2d/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..88183de
> --- /dev/null
> +++
> 
> b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java
> @@ -0,0 +1,265 @@
> +/*
> + * 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 oneInf = new Complex(1, inf);
> +    private Complex oneNegInf = new Complex(1, neginf);
> +    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 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 oneNaN = new Complex(1, nan);
> +    private Complex zeroInf = new Complex(0, inf);
> +    private Complex zeroNaN = new Complex(0, nan);
> +    private Complex nanInf = new Complex(nan, inf);
> +    private Complex nanNegInf = new Complex(nan, neginf);
> +    private Complex nanZero = new Complex(nan, 0);
> +    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 zeroPiTwo = new Complex(0.0, piOverTwo);
> +    private Complex piTwoNaN = new Complex(piOverTwo, nan);
> +    private Complex piNegInf = new Complex(Math.PI, negInf);
> +    private Complex piTwoNegInf = new Complex(piOverTwo, negInf);
> +    private Complex negInfPosInf = new Complex(negInf, inf);
> +    private Complex piTwoNegZero = new Complex(piOverTwo, -0.0);
> +    private Complex threePiFourNegInf = new 
> Complex(threePiOverFour,negInf);
> +    private Complex piFourNegInf = new Complex(piOverFour, negInf);
> +    private Complex infPiTwo = new Complex(inf, piOverTwo);
> +    private Complex infPiFour = new Complex(inf, piOverFour);
> +    private Complex negInfPi = new Complex(negInf, Math.PI);
> +    /**
> +     * ISO C Standard G.6.3
> +     */
> +    @Test
> +    public void testSqrt() {
> +        Complex z1 = new Complex(-2.0, 0.0);
> +        Complex z2 = new Complex(0.0, Math.sqrt(2));
> +        Assert.assertEquals(z1.sqrt(), z2);
> +        z1 = new Complex(-2.0, -0.0);
> +        z2 = new Complex(0.0, -Math.sqrt(2));
> +        Assert.assertEquals(z1.sqrt(), z2);
> +    }
> +
> +    @Test
> +    public void testImplicitTrig() {
> +        Complex z1 = new Complex(3.0);
> +        Complex z2 = new Complex(0.0, 3.0);
> +        Assert.assertEquals(z1.asin(), negI.multiply(z2.asinh()));
> +        Assert.assertEquals(z1.atan(), negI.multiply(z2.atanh()));
> +        Assert.assertEquals(z1.cos(), z2.cosh());
> +        Assert.assertEquals(z1.sin(), negI.multiply(z2.sinh()));
> +        Assert.assertEquals(z1.tan(), negI.multiply(z1.tanh()));
> +    }
> +
> +    /**
> +     * ISO C Standard G.6.1.1
> +     */
> +    @Test
> +    public void testAcos() {
> +        Assert.assertEquals(oneOne.acos().conj(), 
> oneOne.conj().acos());
> +        Assert.assertEquals(Complex.ZERO.acos(), piTwoNegZero);
> +        Assert.assertEquals(negZeroZero.acos(), piTwoNegZero);
> +        Assert.assertEquals(zeroNaN.acos(), piTwoNaN);
> +        Assert.assertEquals(oneInf.acos(), piTwoNegInf);
> +        Assert.assertEquals(oneNaN.acos(), Complex.NaN);
> +        Assert.assertEquals(negInfOne.acos(), piNegInf);
> +        Assert.assertEquals(infOne.acos(), zeroInf);
> +        Assert.assertEquals(negInfPosInf.acos(), threePiFourNegInf);
> +        Assert.assertEquals(infInf.acos(), piFourNegInf);
> +        Assert.assertEquals(infNaN.acos(), naNInf);
> +        Assert.assertEquals(negInfNan.acos(), nanNegInf);
> +        Assert.assertEquals(nanOne.acos(), Complex.NaN);
> +        Assert.assertEquals(nanInf.acos(), nanNegInf);
> +        Assert.assertEquals(Complex.NaN.acos(), Complex.NaN);
> +    }
> +
> +    /**
> +     * ISO C Standard G.6.2.2
> +     */
> +    @Test
> +    public void testAsinh() {
> +        // TODO: test for which Asinh is odd
> +        Assert.assertEquals(oneOne.conj().asinh(), 
> oneOne.asinh().conj());
> +        Assert.assertEquals(Complex.ZERO.asinh(), Complex.ZERO);
> +        Assert.assertEquals(oneInf.asinh(), infPiTwo);
> +        Assert.assertEquals(oneNaN.asinh(), Complex.NaN);
> +        Assert.assertEquals(infOne.asinh(), infZero);
> +        Assert.assertEquals(infInf.asinh(), infPiFour);
> +        Assert.assertEquals(infNaN.asinh(), z1);
> +        Assert.assertEquals(nanZero.asinh(), nanZero);
> +        Assert.assertEquals(nanOne.asinh(), Complex.NaN);
> +        Assert.assertEquals(nanInf.asinh(), infNan);
> +        Assert.assertEquals(Complex.NaN, Complex.NaN);
> +    }
> +
> +    /**
> +     * ISO C Standard G.6.2.3
> +     */
> +    @Test
> +    public void testAtanh() {
> +        Assert.assertEquals(oneOne.conj().atanh(), 
> oneOne.atanh().conj());
> +        Assert.assertEquals(Complex.ZERO.atanh(), Complex.ZERO);
> +        Assert.assertEquals(zeroNaN.atanh(), zeroNaN);
> +        Assert.assertEquals(oneZero.atanh(), infZero);
> +        Assert.assertEquals(oneInf.atanh(),zeroPiTwo);
> +        Assert.assertEquals(oneNaN.atanh(), Complex.NaN);
> +        Assert.assertEquals(infOne.atanh(), zeroPiTwo);
> +        Assert.assertEquals(infInf.atanh(), zeroPiTwo);
> +        Assert.assertEquals(infNaN.atanh(), zeroNaN);
> +        Assert.assertEquals(nanOne.atanh(), Complex.NaN);
> +        Assert.assertEquals(nanInf.atanh(), zeroPiTwo);
> +        Assert.assertEquals(Complex.NaN.atanh(), Complex.NaN);
> +    }
> +
> +    /**
> +     * ISO C Standard G.6.2.4
> +     */
> +    @Test
> +    public void testCosh() {
> +        Assert.assertEquals(oneOne.cosh().conj(), 
> oneOne.conj().cosh());
> +        Assert.assertEquals(Complex.ZERO.cosh(), Complex.ONE);
> +        Assert.assertEquals(zeroInf.cosh(), nanZero);
> +        Assert.assertEquals(zeroNan.cosh(), nanZero);
> +        Assert.assertEquals(oneInf.cosh(), Complex.NaN);
> +        Assert.assertEquals(oneNan.cosh(), Complex.NaN);
> +        Assert.assertEquals(infZero.cosh(), infZero);
> +        // the next test does not appear to make sense:
> +        // (inf + iy) = inf + cis(y)
> +        // skipped
> +        Assert.assertEquals(infInf.cosh(), infNaN);
> +        Assert.assertEquals(infNaN.cosh(), infNaN);
> +        Assert.assertEquals(nanZero.cosh(), nanZero);
> +        Assert.assertEquals(nanOne.cosh(), Complex.NaN);
> +        Assert.assertEquals(Complex.NaN.cosh(), Complex.NaN);
> +    }
> +
> +    /**
> +     * ISO C Standard G.6.2.5
> +     */
> +    @Test
> +    public void testSinh() {
> +        Assert.assertEquals(oneOne.sinh().conj(),
> oneOne.conj().sinh()); // AND CSINH IS ODD
> +        Assert.assertEquals(Complex.ZERO.sinh(), Complex.ZERO);
> +        Assert.assertEquals(zeroInf.sinh(), zeroNaN);
> +        Assert.assertEquals(zeroNaN.sinh(), zeroNaN);
> +        Assert.assertEquals(oneInf.sinh(), Complex.NaN);
> +        Assert.assertEquals(oneNaN.sinh(), Complex.NaN);
> +        Assert.assertEquals(infZero.sinh(), infZero);
> +        // skipped test similar to previous section
> +        Assert.assertEquals(infInf.sinh(), infNaN);
> +        Assert.assertEquals(infNaN.sinh(), infNaN);
> +        Assert.assertEquals(nanZero.sinh(), nanZero);
> +        Assert.assertEquals(nanOne.sinh(), Complex.NaN);
> +        Assert.assertEquals(Complex.NaN.sinh(), Complex.NaN);
> +    }
> +
> +    /**
> +     * ISO C Standard G.6.2.6
> +     */
> +    @Test
> +    public void testTanh() {
> +        Assert.assertEquals(oneOne.tanh().conj(),
> oneOne.conj().tanh()); // AND CSINH IS ODD
> +        Assert.assertEquals(Complex.ZERO.tanh(), Complex.ZERO);
> +        Assert.assertEquals(oneInf.tanh(), Complex.NaN);
> +        Assert.assertEquals(oneNaN.tanh(), Complex.NaN);
> +        //Do Not Understand the Next Test
> +        Assert.assertEquals(infInf.tanh(), oneZero);
> +        Assert.assertEquals(infNaN.tanh(), oneZero);
> +        Assert.assertEquals(nanZero.tanh(), nanZero);
> +        Assert.assertEquals(nanOne.tanh(), Complex.NaN);
> +        Assert.assertEquals(Complex.NaN.tanh(), Complex.NaN);
> +    }
> +
> +    /**
> +     * ISO C Standard G.6.3.1
> +     */
> +    @Test
> +    public void testExp() {
> +        Assert.assertEquals(oneOne.conj().exp(), 
> oneOne.exp().conj());
> +        Assert.assertEquals(Complex.ZERO.exp(), oneZero);
> +        Assert.assertEquals(negZero.exp(), oneZero);
> +        Assert.assertEquals(oneInf.exp(), Complex.NaN);
> +        Assert.assertEquals(oneNaN.exp(), Complex.NaN);
> +        Assert.assertEquals(infZero.exp(), infZero);
> +        // Do not understand next test
> +        Assert.assertEquals(negInfInf.exp(), Complex.ZERO);
> +        Assert.assertEquals(infInf.exp(), infNaN);
> +        Assert.assertEquals(negInfNaN.exp(), Complex.ZERO);
> +        Assert.assertEquals(infNaN.exp(), infNaN);
> +        Assert.assertEquals(nanZero.exp(), nanZero);
> +        Assert.assertEquals(nanOne.exp(), Complex.NaN);
> +        Assert.assertEquals(Complex.NaN.exp(), Complex.NaN);
> +    }
> +
> +    /**
> +     * ISO C Standard G.6.3.2
> +     */
> +    @Test
> +    public void testLog() {
> +        Assert.assertEquals(oneOne.log().conj(), 
> oneOne.conj().log());
> +        Assert.assertEquals(negZeroZero.log(), negInfPi);
> +        Assert.assertEquals(Complex.ZERO.log(), negInfZero);
> +        Assert.assertEquals(oneInf.log(), infPiTwo);
> +        Assert.assertEquals(oneNaN.log(), Complex.NaN);
> +        Assert.assertEquals(negInfOne.log(), infPi);
> +        Assert.assertEquals(infOne.log(), infZero);
> +        Assert.assertEquals(infInf.log(), infPiFour);
> +        Assert.assertEquals(infNaN.log(), infNaN);
> +        Assert.assertEquals(nanOne.log(), Complex.NaN);
> +        Assert.assertEquals(nanInf.log(), infNaN);
> +        Assert.assertEquals(Complex.NaN.log(), Complex.NaN);
> +    }
> +
> +    /**
> +     * ISO C Standard G.6.4.2
> +     */
> +    @Test
> +    public void testSqrt() {
> +        Assert.assertEquals(oneOne.sqrt().conj(), oneOne.conj(), 
> sqrt());
> +        Assert.assertEquals(Complex.ZERO.sqrt(), Complex.ZERO);
> +        Assert.assertEquals(oneInf.sqrt(), infInf);
> +        Assert.assertEquals(negInfOne.sqrt(), zeroNaN);
> +        Assert.assertEquals(infOne.sqrt(), infZero);
> +        Assert.assertEquals(negInfNaN.sqrt(), nanInf);
> +        Assert.assertEquals(infNaN.sqrt(), infNaN);
> +        Assert.assertEquals(nanOne.sqrt(), Complex.NaN);
> +        Assert.assertEquals(Complex.NaN.sqrt(), Complex.NaN);
> +    }
> +}


---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@commons.apache.org
For additional commands, e-mail: dev-help@commons.apache.org


Mime
View raw message