Complex.java
/*
* 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
*
* https://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.
*/
/*
* This is not the original file distributed by the Apache Software Foundation
* It has been modified by the Hipparchus project
*/
package org.hipparchus.complex;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import org.hipparchus.CalculusFieldElement;
import org.hipparchus.exception.LocalizedCoreFormats;
import org.hipparchus.exception.MathIllegalArgumentException;
import org.hipparchus.exception.NullArgumentException;
import org.hipparchus.util.FastMath;
import org.hipparchus.util.FieldSinCos;
import org.hipparchus.util.FieldSinhCosh;
import org.hipparchus.util.MathArrays;
import org.hipparchus.util.MathUtils;
import org.hipparchus.util.Precision;
import org.hipparchus.util.SinCos;
import org.hipparchus.util.SinhCosh;
/**
* 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.hipparchus.util.Precision#equals(double,double,int)
* equals for primitive double} in {@link org.hipparchus.util.Precision}
* conforms with IEEE-754 while this class conforms with the standard behavior
* for Java object types.
*/
public class Complex implements CalculusFieldElement<Complex>, Comparable<Complex>, Serializable {
/** The square root of -1. A number representing "0.0 + 1.0i". */
public static final Complex I = new Complex(0.0, 1.0);
/** The square root of -1. A number representing "0.0 - 1.0i".
* @since 1.7
*/
public static final Complex MINUS_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 "-1.0 + 0.0i".
* @since 1.7
*/
public static final Complex MINUS_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);
/** A complex number representing "π + 0.0i". */
public static final Complex PI = new Complex(FastMath.PI, 0.0);
/** A real number representing log(10). */
private static final double LOG10 = 2.302585092994045684;
/** Serializable version identifier */
private static final long serialVersionUID = 20160305L;
/** 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.
*
* @return the norm.
* @since 2.0
*/
@Override
public Complex abs() {
// we check NaN here because FastMath.hypot checks it after infinity
return isNaN ? NaN : createComplex(FastMath.hypot(real, imaginary), 0.0);
}
/** {@inheritDoc} */
@Override
public double norm() {
// we check NaN here because FastMath.hypot checks it after infinity
return isNaN ? Double.NaN : FastMath.hypot(real, imaginary);
}
/**
* 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}.
* @throws NullArgumentException if {@code addend} is {@code null}.
*/
@Override
public Complex add(Complex addend) throws NullArgumentException {
MathUtils.checkNotNull(addend);
if (isNaN || addend.isNaN) {
return NaN;
}
return createComplex(real + addend.getRealPart(),
imaginary + addend.getImaginaryPart());
}
/**
* 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)
*/
@Override
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}.
* @throws NullArgumentException if {@code divisor} is {@code null}.
*/
@Override
public Complex divide(Complex divisor)
throws NullArgumentException {
MathUtils.checkNotNull(divisor);
if (isNaN || divisor.isNaN) {
return NaN;
}
final double c = divisor.getRealPart();
final double d = divisor.getImaginaryPart();
if (c == 0.0 && d == 0.0) {
return NaN;
}
if (divisor.isInfinite() && !isInfinite()) {
return ZERO;
}
if (FastMath.abs(c) < FastMath.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)
*/
@Override
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);
}
/** {@inheritDoc} */
@Override
public Complex reciprocal() {
if (isNaN) {
return NaN;
}
if (real == 0.0 && imaginary == 0.0) {
return INF;
}
if (isInfinite) {
return ZERO;
}
if (FastMath.abs(real) < FastMath.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 MathUtils.equals(real, c.real) &&
MathUtils.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;
}
return 37 * (17 * MathUtils.hash(imaginary) +
MathUtils.hash(real));
}
/** {@inheritDoc}
* <p>
* This implementation considers +0.0 and -0.0 to be equal for both
* real and imaginary components.
* </p>
* @since 1.8
*/
@Override
public boolean isZero() {
return real == 0.0 && imaginary == 0.0;
}
/**
* Access the imaginary part.
*
* @return the imaginary part.
*/
public double getImaginary() {
return imaginary;
}
/**
* Access the imaginary part.
*
* @return the imaginary part.
* @since 2.0
*/
public double getImaginaryPart() {
return imaginary;
}
/**
* Access the real part.
*
* @return the real part.
*/
@Override
public double getReal() {
return real;
}
/**
* Access the real part.
*
* @return the real part.
* @since 2.0
*/
public double getRealPart() {
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.
*/
@Override
public boolean isNaN() {
return isNaN;
}
/** Check whether the instance is real (i.e. imaginary part is zero).
* @return true if imaginary part is zero
* @since 1.7
*/
public boolean isReal() {
return imaginary == 0.0;
}
/** Check whether the instance is an integer (i.e. imaginary part is zero and real part has no fractional part).
* @return true if imaginary part is zero and real part has no fractional part
* @since 1.7
*/
public boolean isMathematicalInteger() {
return isReal() && Precision.isMathematicalInteger(real);
}
/**
* 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}.
*/
@Override
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}.
* @throws NullArgumentException if {@code factor} is {@code null}.
*/
@Override
public Complex multiply(Complex factor)
throws NullArgumentException {
MathUtils.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(MathArrays.linearCombination(real, factor.real, -imaginary, factor.imaginary),
MathArrays.linearCombination(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)
*/
@Override
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)
*/
@Override
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);
}
/** Compute this * i.
* @return this * i
* @since 2.0
*/
public Complex multiplyPlusI() {
return createComplex(-imaginary, real);
}
/** Compute this *- -i.
* @return this * i
* @since 2.0
*/
public Complex multiplyMinusI() {
return createComplex(imaginary, -real);
}
/** {@inheritDoc} */
@Override
public Complex square() {
return multiply(this);
}
/**
* 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}.
*/
@Override
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}.
* @throws NullArgumentException if {@code subtrahend} is {@code null}.
*/
@Override
public Complex subtract(Complex subtrahend)
throws NullArgumentException {
MathUtils.checkNotNull(subtrahend);
if (isNaN || subtrahend.isNaN) {
return NaN;
}
return createComplex(real - subtrahend.getRealPart(),
imaginary - subtrahend.getImaginaryPart());
}
/**
* 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)
*/
@Override
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.
*/
@Override
public Complex acos() {
if (isNaN) {
return NaN;
}
return this.add(this.sqrt1z().multiplyPlusI()).log().multiplyMinusI();
}
/**
* 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.
*/
@Override
public Complex asin() {
if (isNaN) {
return NaN;
}
return sqrt1z().add(this.multiplyPlusI()).log().multiplyMinusI();
}
/**
* 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((1 - iz)/(1 + 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 tangent of this complex number
*/
@Override
public Complex atan() {
if (isNaN) {
return NaN;
}
if (real == 0.0) {
// singularity at ±i
if (imaginary * imaginary - 1.0 == 0.0) {
return NaN;
}
// branch cut on imaginary axis
final Complex tmp = createComplex((1 + imaginary) / (1 - imaginary), 0.0).log().multiplyPlusI().multiply(0.5);
return createComplex(FastMath.copySign(tmp.real, real), tmp.imaginary);
} else {
// regular formula
final Complex n = createComplex(1 + imaginary, -real);
final Complex d = createComplex(1 - imaginary, real);
return n.divide(d).log().multiplyPlusI().multiply(0.5);
}
}
/**
* 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 FastMath#sin}, {@link FastMath#cos},
* {@link FastMath#cosh} and {@link FastMath#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 ± INFINITY i) = 1 \u2213 INFINITY i
* cos(±INFINITY + i) = NaN + NaN i
* cos(±INFINITY ± INFINITY i) = NaN + NaN i
* </code>
* </pre>
*
* @return the cosine of this complex number.
*/
@Override
public Complex cos() {
if (isNaN) {
return NaN;
}
final SinCos scr = FastMath.sinCos(real);
final SinhCosh schi = FastMath.sinhCosh(imaginary);
return createComplex(scr.cos() * schi.cosh(), -scr.sin() * schi.sinh());
}
/**
* 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 FastMath#sin}, {@link FastMath#cos},
* {@link FastMath#cosh} and {@link FastMath#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 ± INFINITY i) = NaN + NaN i
* cosh(±INFINITY + i) = INFINITY ± INFINITY i
* cosh(±INFINITY ± INFINITY i) = NaN + NaN i
* </code>
* </pre>
*
* @return the hyperbolic cosine of this complex number.
*/
@Override
public Complex cosh() {
if (isNaN) {
return NaN;
}
final SinhCosh schr = FastMath.sinhCosh(real);
final SinCos sci = FastMath.sinCos(imaginary);
return createComplex(schr.cosh() * sci.cos(), schr.sinh() * sci.sin());
}
/**
* 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 FastMath#exp(double)} p}, {@link FastMath#cos(double)}, and
* {@link FastMath#sin(double)}.
* <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 ± INFINITY i) = NaN + NaN i
* exp(INFINITY + i) = INFINITY + INFINITY i
* exp(-INFINITY + i) = 0 + 0i
* exp(±INFINITY ± INFINITY i) = NaN + NaN i
* </code>
* </pre>
*
* @return <code><i>e</i><sup>this</sup></code>.
*/
@Override
public Complex exp() {
if (isNaN) {
return NaN;
}
final double expReal = FastMath.exp(real);
final SinCos sc = FastMath.sinCos(imaginary);
return createComplex(expReal * sc.cos(), expReal * sc.sin());
}
/** {@inheritDoc}
* @since 1.7
*/
@Override
public Complex expm1() {
if (isNaN) {
return NaN;
}
final double expm1Real = FastMath.expm1(real);
final SinCos sc = FastMath.sinCos(imaginary);
return createComplex(expm1Real * sc.cos(), expm1Real * sc.sin());
}
/**
* 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 FastMath#log(double)},
* {@code |a + bi|} is the modulus, {@link Complex#abs}, and
* {@code arg(a + bi) = }{@link FastMath#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 ± INFINITY i) = INFINITY ± (π/2)i
* log(INFINITY + i) = INFINITY + 0i
* log(-INFINITY + i) = INFINITY + πi
* log(INFINITY ± INFINITY i) = INFINITY ± (π/4)i
* log(-INFINITY ± INFINITY i) = INFINITY ± (3π/4)i
* log(0 + 0i) = -INFINITY + 0i
* </code>
* </pre>
*
* @return the value <code>ln this</code>, the natural logarithm
* of {@code this}.
*/
@Override
public Complex log() {
if (isNaN) {
return NaN;
}
return createComplex(FastMath.log(FastMath.hypot(real, imaginary)),
FastMath.atan2(imaginary, real));
}
/** {@inheritDoc}
* @since 1.7
*/
@Override
public Complex log1p() {
return add(1.0).log();
}
/** {@inheritDoc}
* @since 1.7
*/
@Override
public Complex log10() {
return log().divide(LOG10);
}
/**
* Returns of value of this complex number raised to the power of {@code x}.
* <p>
* If {@code x} is a real number whose real part has an integer value, returns {@link #pow(int)},
* if both {@code this} and {@code x} are real and {@link FastMath#pow(double, double)}
* with the corresponding real arguments would return a finite number (neither NaN
* nor infinite), then returns the same value converted to {@code Complex},
* with the same special cases.
* In all other cases real cases, implements y<sup>x</sup> = exp(x·log(y)).
* </p>
*
* @param x exponent to which this {@code Complex} is to be raised.
* @return <code> this<sup>x</sup></code>.
* @throws NullArgumentException if x is {@code null}.
*/
@Override
public Complex pow(Complex x)
throws NullArgumentException {
MathUtils.checkNotNull(x);
if (x.imaginary == 0.0) {
final int nx = (int) FastMath.rint(x.real);
if (x.real == nx) {
// integer power
return pow(nx);
} else if (this.imaginary == 0.0) {
// check real implementation that handles a bunch of special cases
final double realPow = FastMath.pow(this.real, x.real);
if (Double.isFinite(realPow)) {
return createComplex(realPow, 0);
}
}
}
// generic implementation
return this.log().multiply(x).exp();
}
/**
* Returns of value of this complex number raised to the power of {@code x}.
* <p>
* If {@code x} has an integer value, returns {@link #pow(int)},
* if {@code this} is real and {@link FastMath#pow(double, double)}
* with the corresponding real arguments would return a finite number (neither NaN
* nor infinite), then returns the same value converted to {@code Complex},
* with the same special cases.
* In all other cases real cases, implements y<sup>x</sup> = exp(x·log(y)).
* </p>
*
* @param x exponent to which this {@code Complex} is to be raised.
* @return <code> this<sup>x</sup></code>.
*/
@Override
public Complex pow(double x) {
final int nx = (int) FastMath.rint(x);
if (x == nx) {
// integer power
return pow(nx);
} else if (this.imaginary == 0.0) {
// check real implementation that handles a bunch of special cases
final double realPow = FastMath.pow(this.real, x);
if (Double.isFinite(realPow)) {
return createComplex(realPow, 0);
}
}
// generic implementation
return this.log().multiply(x).exp();
}
/** {@inheritDoc}
* @since 1.7
*/
@Override
public Complex pow(final int n) {
Complex result = ONE;
final boolean invert;
int p = n;
if (p < 0) {
invert = true;
p = -p;
} else {
invert = false;
}
// Exponentiate by successive squaring
Complex square = this;
while (p > 0) {
if ((p & 0x1) > 0) {
result = result.multiply(square);
}
square = square.multiply(square);
p = p >> 1;
}
return invert ? result.reciprocal() : result;
}
/**
* 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 FastMath#sin}, {@link FastMath#cos},
* {@link FastMath#cosh} and {@link FastMath#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 ± INFINITY i) = 1 ± INFINITY i
* sin(±INFINITY + i) = NaN + NaN i
* sin(±INFINITY ± INFINITY i) = NaN + NaN i
* </code>
* </pre>
*
* @return the sine of this complex number.
*/
@Override
public Complex sin() {
if (isNaN) {
return NaN;
}
final SinCos scr = FastMath.sinCos(real);
final SinhCosh schi = FastMath.sinhCosh(imaginary);
return createComplex(scr.sin() * schi.cosh(), scr.cos() * schi.sinh());
}
/** {@inheritDoc}
*/
@Override
public FieldSinCos<Complex> sinCos() {
if (isNaN) {
return new FieldSinCos<>(NaN, NaN);
}
final SinCos scr = FastMath.sinCos(real);
final SinhCosh schi = FastMath.sinhCosh(imaginary);
return new FieldSinCos<>(createComplex(scr.sin() * schi.cosh(), scr.cos() * schi.sinh()),
createComplex(scr.cos() * schi.cosh(), -scr.sin() * schi.sinh()));
}
/** {@inheritDoc}
* @since 1.7
*/
@Override
public Complex atan2(Complex x) {
// compute r = sqrt(x^2+y^2)
final Complex r = x.square().add(multiply(this)).sqrt();
if (FastMath.copySign(1.0, x.real) >= 0) {
// compute atan2(y, x) = 2 atan(y / (r + x))
return divide(r.add(x)).atan().multiply(2);
} else {
// compute atan2(y, x) = +/- pi - 2 atan(y / (r - x))
return divide(r.subtract(x)).atan().multiply(-2).add(FastMath.PI);
}
}
/** {@inheritDoc}
* <p>
* Branch cuts are on the real axis, below +1.
* </p>
* @since 1.7
*/
@Override
public Complex acosh() {
final Complex sqrtPlus = add(1).sqrt();
final Complex sqrtMinus = subtract(1).sqrt();
return add(sqrtPlus.multiply(sqrtMinus)).log();
}
/** {@inheritDoc}
* <p>
* Branch cuts are on the imaginary axis, above +i and below -i.
* </p>
* @since 1.7
*/
@Override
public Complex asinh() {
return add(multiply(this).add(1.0).sqrt()).log();
}
/** {@inheritDoc}
* <p>
* Branch cuts are on the real axis, above +1 and below -1.
* </p>
* @since 1.7
*/
@Override
public Complex atanh() {
final Complex logPlus = add(1).log();
final Complex logMinus = createComplex(1 - real, -imaginary).log();
return logPlus.subtract(logMinus).multiply(0.5);
}
/**
* 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 FastMath#sin}, {@link FastMath#cos},
* {@link FastMath#cosh} and {@link FastMath#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 ± INFINITY i) = NaN + NaN i
* sinh(±INFINITY + i) = ± INFINITY + INFINITY i
* sinh(±INFINITY ± INFINITY i) = NaN + NaN i
* </code>
* </pre>
*
* @return the hyperbolic sine of {@code this}.
*/
@Override
public Complex sinh() {
if (isNaN) {
return NaN;
}
final SinhCosh schr = FastMath.sinhCosh(real);
final SinCos sci = FastMath.sinCos(imaginary);
return createComplex(schr.sinh() * sci.cos(), schr.cosh() * sci.sin());
}
/** {@inheritDoc}
*/
@Override
public FieldSinhCosh<Complex> sinhCosh() {
if (isNaN) {
return new FieldSinhCosh<>(NaN, NaN);
}
final SinhCosh schr = FastMath.sinhCosh(real);
final SinCos sci = FastMath.sinCos(imaginary);
return new FieldSinhCosh<>(createComplex(schr.sinh() * sci.cos(), schr.cosh() * sci.sin()),
createComplex(schr.cosh() * sci.cos(), schr.sinh() * sci.sin()));
}
/**
* 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 ≥ 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 FastMath#abs(double) abs(a)}</li>
* <li>{@code |a + bi| = }{@link FastMath#hypot(double, double) hypot(a, b)}</li>
* <li>{@code sign(b) = }{@link FastMath#copySign(double, double) copySign(1, b)}
* </ul>
* The real part is therefore always nonnegative.
* <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>
* sqrt(1 ± ∞ i) = ∞ + NaN i
* sqrt(∞ + i) = ∞ + 0i
* sqrt(-∞ + i) = 0 + ∞ i
* sqrt(∞ ± ∞ i) = ∞ + NaN i
* sqrt(-∞ ± ∞ i) = NaN ± ∞ i
* </code>
* </pre>
*
* @return the square root of {@code this} with nonnegative real part.
*/
@Override
public Complex sqrt() {
if (isNaN) {
return NaN;
}
if (real == 0.0 && imaginary == 0.0) {
return ZERO;
}
double t = FastMath.sqrt((FastMath.abs(real) + FastMath.hypot(real, imaginary)) * 0.5);
if (FastMath.copySign(1, real) >= 0.0) {
return createComplex(t, imaginary / (2.0 * t));
} else {
return createComplex(FastMath.abs(imaginary) / (2.0 * t),
FastMath.copySign(t, imaginary));
}
}
/**
* 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.square()))}.
* <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() {
final Complex t2 = this.square();
return createComplex(1 - t2.real, -t2.imaginary).sqrt();
}
/** {@inheritDoc}
* <p>
* This implementation compute the principal cube root by using a branch cut along real negative axis.
* </p>
* @since 1.7
*/
@Override
public Complex cbrt() {
final double magnitude = FastMath.cbrt(norm());
final SinCos sc = FastMath.sinCos(getArgument() / 3);
return createComplex(magnitude * sc.cos(), magnitude * sc.sin());
}
/** {@inheritDoc}
* <p>
* This implementation compute the principal n<sup>th</sup> root by using a branch cut along real negative axis.
* </p>
* @since 1.7
*/
@Override
public Complex rootN(int n) {
final double magnitude = FastMath.pow(norm(), 1.0 / n);
final SinCos sc = FastMath.sinCos(getArgument() / n);
return createComplex(magnitude * sc.cos(), magnitude * sc.sin());
}
/**
* 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 FastMath#sin}, {@link FastMath#cos}, {@link FastMath#cosh} and
* {@link FastMath#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 ± INFINITY i) = 0 ± i
* tan(±INFINITY + bi) = NaN + NaN i
* tan(±INFINITY ± INFINITY i) = NaN + NaN i
* tan(±π/2 + 0 i) = ±INFINITY + NaN i
* </code>
* </pre>
*
* @return the tangent of {@code this}.
*/
@Override
public Complex tan() {
if (isNaN || Double.isInfinite(real)) {
return NaN;
}
if (imaginary > 20.0) {
return I;
}
if (imaginary < -20.0) {
return MINUS_I;
}
final SinCos sc2r = FastMath.sinCos(2.0 * real);
double imaginary2 = 2.0 * imaginary;
double d = sc2r.cos() + FastMath.cosh(imaginary2);
return createComplex(sc2r.sin() / d, FastMath.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 FastMath#sin}, {@link FastMath#cos}, {@link FastMath#cosh} and
* {@link FastMath#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 ± INFINITY i) = NaN + NaN i
* tanh(±INFINITY + bi) = ±1 + 0 i
* tanh(±INFINITY ± INFINITY i) = NaN + NaN i
* tanh(0 + (π/2)i) = NaN + INFINITY i
* </code>
* </pre>
*
* @return the hyperbolic tangent of {@code this}.
*/
@Override
public Complex tanh() {
if (isNaN || Double.isInfinite(imaginary)) {
return NaN;
}
if (real > 20.0) {
return ONE;
}
if (real < -20.0) {
return MINUS_ONE;
}
double real2 = 2.0 * real;
final SinCos sc2i = FastMath.sinCos(2.0 * imaginary);
double d = FastMath.cosh(real2) + sc2i.cos();
return createComplex(FastMath.sinh(real2) / d, sc2i.sin() / 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 FastMath.atan2(getImaginaryPart(), getRealPart());
}
/**
* 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πk/n) + i (sin(phi + 2π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}.
* @throws MathIllegalArgumentException if {@code n <= 0}.
*/
public List<Complex> nthRoot(int n) throws MathIllegalArgumentException {
if (n <= 0) {
throw new MathIllegalArgumentException(LocalizedCoreFormats.CANNOT_COMPUTE_NTH_ROOT_FOR_NEGATIVE_N,
n);
}
final List<Complex> result = new ArrayList<>();
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 = FastMath.pow(FastMath.hypot(real, imaginary), 1.0 / n);
// Compute nth roots of complex number with k = 0, 1, ... n-1
final double nthPhi = getArgument() / n;
final double slice = 2 * FastMath.PI / n;
double innerPart = nthPhi;
for (int k = 0; k < n ; k++) {
// inner part
final SinCos scInner = FastMath.sinCos(innerPart);
final double realPart = nthRootOfAbs * scInner.cos();
final double imaginaryPart = nthRootOfAbs * scInner.sin();
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);
}
/** {@inheritDoc} */
@Override
public Complex newInstance(double realPart) {
return valueOf(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 ComplexField getField() {
return ComplexField.getInstance();
}
/** {@inheritDoc} */
@Override
public String toString() {
return "(" + real + ", " + imaginary + ")";
}
/** {@inheritDoc}
* @since 1.7
*/
@Override
public Complex scalb(int n) {
return createComplex(FastMath.scalb(real, n), FastMath.scalb(imaginary, n));
}
/** {@inheritDoc}
*/
@Override
public Complex ulp() {
return createComplex(FastMath.ulp(real), FastMath.ulp(imaginary));
}
/** {@inheritDoc}
* @since 1.7
*/
@Override
public Complex hypot(Complex y) {
if (isInfinite() || y.isInfinite()) {
return INF;
} else if (isNaN() || y.isNaN()) {
return NaN;
} else {
return square().add(y.square()).sqrt();
}
}
/** {@inheritDoc}
* @since 1.7
*/
@Override
public Complex linearCombination(final Complex[] a, final Complex[] b)
throws MathIllegalArgumentException {
final int n = 2 * a.length;
final double[] realA = new double[n];
final double[] realB = new double[n];
final double[] imaginaryA = new double[n];
final double[] imaginaryB = new double[n];
for (int i = 0; i < a.length; ++i) {
final Complex ai = a[i];
final Complex bi = b[i];
realA[2 * i ] = +ai.real;
realA[2 * i + 1] = -ai.imaginary;
realB[2 * i ] = +bi.real;
realB[2 * i + 1] = +bi.imaginary;
imaginaryA[2 * i ] = +ai.real;
imaginaryA[2 * i + 1] = +ai.imaginary;
imaginaryB[2 * i ] = +bi.imaginary;
imaginaryB[2 * i + 1] = +bi.real;
}
return createComplex(MathArrays.linearCombination(realA, realB),
MathArrays.linearCombination(imaginaryA, imaginaryB));
}
/** {@inheritDoc}
* @since 1.7
*/
@Override
public Complex linearCombination(final double[] a, final Complex[] b)
throws MathIllegalArgumentException {
final int n = a.length;
final double[] realB = new double[n];
final double[] imaginaryB = new double[n];
for (int i = 0; i < a.length; ++i) {
final Complex bi = b[i];
realB[i] = +bi.real;
imaginaryB[i] = +bi.imaginary;
}
return createComplex(MathArrays.linearCombination(a, realB),
MathArrays.linearCombination(a, imaginaryB));
}
/** {@inheritDoc}
* @since 1.7
*/
@Override
public Complex linearCombination(final Complex a1, final Complex b1, final Complex a2, final Complex b2) {
return createComplex(MathArrays.linearCombination(+a1.real, b1.real,
-a1.imaginary, b1.imaginary,
+a2.real, b2.real,
-a2.imaginary, b2.imaginary),
MathArrays.linearCombination(+a1.real, b1.imaginary,
+a1.imaginary, b1.real,
+a2.real, b2.imaginary,
+a2.imaginary, b2.real));
}
/** {@inheritDoc}
* @since 1.7
*/
@Override
public Complex linearCombination(final double a1, final Complex b1, final double a2, final Complex b2) {
return createComplex(MathArrays.linearCombination(a1, b1.real,
a2, b2.real),
MathArrays.linearCombination(a1, b1.imaginary,
a2, b2.imaginary));
}
/** {@inheritDoc}
* @since 1.7
*/
@Override
public Complex linearCombination(final Complex a1, final Complex b1,
final Complex a2, final Complex b2,
final Complex a3, final Complex b3) {
return linearCombination(new Complex[] { a1, a2, a3 },
new Complex[] { b1, b2, b3 });
}
/** {@inheritDoc}
* @since 1.7
*/
@Override
public Complex linearCombination(final double a1, final Complex b1,
final double a2, final Complex b2,
final double a3, final Complex b3) {
return linearCombination(new double[] { a1, a2, a3 },
new Complex[] { b1, b2, b3 });
}
/** {@inheritDoc}
* @since 1.7
*/
@Override
public Complex linearCombination(final Complex a1, final Complex b1,
final Complex a2, final Complex b2,
final Complex a3, final Complex b3,
final Complex a4, final Complex b4) {
return linearCombination(new Complex[] { a1, a2, a3, a4 },
new Complex[] { b1, b2, b3, b4 });
}
/** {@inheritDoc}
* @since 1.7
*/
@Override
public Complex linearCombination(final double a1, final Complex b1,
final double a2, final Complex b2,
final double a3, final Complex b3,
final double a4, final Complex b4) {
return linearCombination(new double[] { a1, a2, a3, a4 },
new Complex[] { b1, b2, b3, b4 });
}
/** {@inheritDoc} */
@Override
public Complex getPi() {
return PI;
}
/** {@inheritDoc}
* @since 1.7
*/
@Override
public Complex ceil() {
return createComplex(FastMath.ceil(getRealPart()), FastMath.ceil(getImaginaryPart()));
}
/** {@inheritDoc}
* @since 1.7
*/
@Override
public Complex floor() {
return createComplex(FastMath.floor(getRealPart()), FastMath.floor(getImaginaryPart()));
}
/** {@inheritDoc}
* @since 1.7
*/
@Override
public Complex rint() {
return createComplex(FastMath.rint(getRealPart()), FastMath.rint(getImaginaryPart()));
}
/** {@inheritDoc}
* <p>
* for complex numbers, the integer n corresponding to {@code this.subtract(remainder(a)).divide(a)}
* is a <a href="https://en.wikipedia.org/wiki/Gaussian_integer">Wikipedia - Gaussian integer</a>.
* </p>
* @since 1.7
*/
@Override
public Complex remainder(final double a) {
return createComplex(FastMath.IEEEremainder(getRealPart(), a), FastMath.IEEEremainder(getImaginaryPart(), a));
}
/** {@inheritDoc}
* <p>
* for complex numbers, the integer n corresponding to {@code this.subtract(remainder(a)).divide(a)}
* is a <a href="https://en.wikipedia.org/wiki/Gaussian_integer">Wikipedia - Gaussian integer</a>.
* </p>
* @since 1.7
*/
@Override
public Complex remainder(final Complex a) {
final Complex complexQuotient = divide(a);
final double qRInt = FastMath.rint(complexQuotient.real);
final double qIInt = FastMath.rint(complexQuotient.imaginary);
return createComplex(real - qRInt * a.real + qIInt * a.imaginary,
imaginary - qRInt * a.imaginary - qIInt * a.real);
}
/** {@inheritDoc}
* @since 2.0
*/
@Override
public Complex sign() {
if (isNaN() || isZero()) {
return this;
} else {
return this.divide(FastMath.hypot(real, imaginary));
}
}
/** {@inheritDoc}
* <p>
* The signs of real and imaginary parts are copied independently.
* </p>
* @since 1.7
*/
@Override
public Complex copySign(final Complex z) {
return createComplex(FastMath.copySign(getRealPart(), z.getRealPart()),
FastMath.copySign(getImaginaryPart(), z.getImaginaryPart()));
}
/** {@inheritDoc}
* @since 1.7
*/
@Override
public Complex copySign(double r) {
return createComplex(FastMath.copySign(getRealPart(), r), FastMath.copySign(getImaginaryPart(), r));
}
/** {@inheritDoc} */
@Override
public Complex toDegrees() {
return createComplex(FastMath.toDegrees(getRealPart()), FastMath.toDegrees(getImaginaryPart()));
}
/** {@inheritDoc} */
@Override
public Complex toRadians() {
return createComplex(FastMath.toRadians(getRealPart()), FastMath.toRadians(getImaginaryPart()));
}
/** {@inheritDoc}
* <p>
* Comparison us performed using real ordering as the primary sort order and
* imaginary ordering as the secondary sort order.
* </p>
* @since 3.0
*/
@Override
public int compareTo(final Complex o) {
final int cR = Double.compare(getReal(), o.getReal());
if (cR == 0) {
return Double.compare(getImaginary(),o.getImaginary());
} else {
return cR;
}
}
}