You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by er...@apache.org on 2017/01/18 13:54:46 UTC
[07/16] commons-numbers git commit: Cleanup (massive delete).
http://git-wip-us.apache.org/repos/asf/commons-numbers/blob/a752ab8d/src/main/java/org/apache/commons/complex/ComplexFormat.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/complex/ComplexFormat.java b/src/main/java/org/apache/commons/complex/ComplexFormat.java
deleted file mode 100644
index feed97d..0000000
--- a/src/main/java/org/apache/commons/complex/ComplexFormat.java
+++ /dev/null
@@ -1,595 +0,0 @@
-/*
- * 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.complex;
-
-import java.text.FieldPosition;
-import java.text.NumberFormat;
-import java.text.ParsePosition;
-import java.util.Locale;
-import org.apache.commons.complex.Complex;
-
-/**
- * Formats a Complex number in cartesian format "Re(c) + Im(c)i". 'i' can
- * be replaced with 'j' (or anything else), and the number format for both real
- * and imaginary parts can be configured.
- *
- */
-public class ComplexFormat {
-
- /** The default imaginary character. */
- private static final String DEFAULT_IMAGINARY_CHARACTER = "i";
- /** The notation used to signify the imaginary part of the complex number. */
- private final String imaginaryCharacter;
- /** The format used for the imaginary part. */
- private final NumberFormat imaginaryFormat;
- /** The format used for the real part. */
- private final NumberFormat realFormat;
-
- /**
- * Create an instance with the default imaginary character, 'i', and the
- * default number format for both real and imaginary parts.
- */
- public ComplexFormat() {
- this.imaginaryCharacter = DEFAULT_IMAGINARY_CHARACTER;
- this.imaginaryFormat = getDefaultNumberFormat();
- this.realFormat = imaginaryFormat;
- }
-
- /**
- * Create an instance with a custom number format for both real and
- * imaginary parts.
- * @param format the custom format for both real and imaginary parts.
- * @throws NullArgumentException if {@code realFormat} is {@code null}.
- */
- public ComplexFormat(NumberFormat format) {
- if (format == null) {
- throw new RuntimeException("Null argument to ComplexFormat");
- }
- this.imaginaryCharacter = DEFAULT_IMAGINARY_CHARACTER;
- this.imaginaryFormat = format;
- this.realFormat = format;
- }
-
- /**
- * Create an instance with a custom number format for the real part and a
- * custom number format for the imaginary part.
- * @param realFormat the custom format for the real part.
- * @param imaginaryFormat the custom format for the imaginary part.
- * @throws NullArgumentException if {@code imaginaryFormat} is {@code null}.
- * @throws NullArgumentException if {@code realFormat} is {@code null}.
- */
- public ComplexFormat(NumberFormat realFormat, NumberFormat imaginaryFormat) {
- if (imaginaryFormat == null || realFormat == null) {
- throw new RuntimeException("Null argument to ComplexFormat");
- }
- this.imaginaryCharacter = DEFAULT_IMAGINARY_CHARACTER;
- this.imaginaryFormat = imaginaryFormat;
- this.realFormat = realFormat;
- }
-
- /**
- * Create an instance with a custom imaginary character, and the default
- * number format for both real and imaginary parts.
- * @param imaginaryCharacter The custom imaginary character.
- * @throws NullArgumentException if {@code imaginaryCharacter} is
- * {@code null}.
- * @throws NoDataException if {@code imaginaryCharacter} is an
- * empty string.
- */
- public ComplexFormat(String imaginaryCharacter) {
- this(imaginaryCharacter, getDefaultNumberFormat());
- }
-
- /**
- * Create an instance with a custom imaginary character, and a custom number
- * format for both real and imaginary parts.
- * @param imaginaryCharacter The custom imaginary character.
- * @param format the custom format for both real and imaginary parts.
- * @throws NullArgumentException if {@code imaginaryCharacter} is
- * {@code null}.
- * @throws NoDataException if {@code imaginaryCharacter} is an
- * empty string.
- * @throws NullArgumentException if {@code format} is {@code null}.
- */
- public ComplexFormat(String imaginaryCharacter, NumberFormat format) {
- this(imaginaryCharacter, format, format);
- }
-
- /**
- * Create an instance with a custom imaginary character, a custom number
- * format for the real part, and a custom number format for the imaginary
- * part.
- *
- * @param imaginaryCharacter The custom imaginary character.
- * @param realFormat the custom format for the real part.
- * @param imaginaryFormat the custom format for the imaginary part.
- * @throws NullArgumentException if {@code imaginaryCharacter} is
- * {@code null}.
- * @throws NoDataException if {@code imaginaryCharacter} is an
- * empty string.
- * @throws NullArgumentException if {@code imaginaryFormat} is {@code null}.
- * @throws NullArgumentException if {@code realFormat} is {@code null}.
- */
- public ComplexFormat(String imaginaryCharacter,
- NumberFormat realFormat,
- NumberFormat imaginaryFormat) {
- if (imaginaryCharacter == null) {
- throw new RuntimeException("Null argument to ComplexFormat");
- }
- if (imaginaryCharacter.length() == 0) {
- throw new RuntimeException("Empty argument to ComplexFormat");
- }
- if (imaginaryFormat == null) {
- throw new RuntimeException("Null imaginary argument to ComplexFormat");
- }
- if (realFormat == null) {
- throw new RuntimeException("Null real argument to ComplexFormat");
- }
-
- this.imaginaryCharacter = imaginaryCharacter;
- this.imaginaryFormat = imaginaryFormat;
- this.realFormat = realFormat;
- }
-
- /**
- * Get the set of locales for which complex formats are available.
- * <p>This is the same set as the {@link NumberFormat} set.</p>
- * @return available complex format locales.
- */
- public static Locale[] getAvailableLocales() {
- return NumberFormat.getAvailableLocales();
- }
-
- /**
- * This method calls {@link #format(Object,StringBuffer,FieldPosition)}.
- *
- * @param c Complex object to format.
- * @return A formatted number in the form "Re(c) + Im(c)i".
- */
- public String format(Complex c) {
- return format(c, new StringBuffer(), new FieldPosition(0)).toString();
- }
-
- /**
- * This method calls {@link #format(Object,StringBuffer,FieldPosition)}.
- *
- * @param c Double object to format.
- * @return A formatted number.
- */
- public String format(Double c) {
- return format(new Complex(c, 0), new StringBuffer(), new FieldPosition(0)).toString();
- }
-
- /**
- * Formats a {@link Complex} object to produce a string.
- *
- * @param complex the object to format.
- * @param toAppendTo where the text is to be appended
- * @param pos On input: an alignment field, if desired. On output: the
- * offsets of the alignment field
- * @return the value passed in as toAppendTo.
- */
- public StringBuffer format(Complex complex, StringBuffer toAppendTo,
- FieldPosition pos) {
- pos.setBeginIndex(0);
- pos.setEndIndex(0);
-
- // format real
- double re = complex.getReal();
- formatDouble(re, getRealFormat(), toAppendTo, pos);
-
- // format sign and imaginary
- double im = complex.getImaginary();
- StringBuffer imAppendTo;
- if (im < 0.0) {
- toAppendTo.append(" - ");
- imAppendTo = formatImaginary(-im, new StringBuffer(), pos);
- toAppendTo.append(imAppendTo);
- toAppendTo.append(getImaginaryCharacter());
- } else if (im > 0.0 || Double.isNaN(im)) {
- toAppendTo.append(" + ");
- imAppendTo = formatImaginary(im, new StringBuffer(), pos);
- toAppendTo.append(imAppendTo);
- toAppendTo.append(getImaginaryCharacter());
- }
-
- return toAppendTo;
- }
-
- /**
- * Format the absolute value of the imaginary part.
- *
- * @param absIm Absolute value of the imaginary part of a complex number.
- * @param toAppendTo where the text is to be appended.
- * @param pos On input: an alignment field, if desired. On output: the
- * offsets of the alignment field.
- * @return the value passed in as toAppendTo.
- */
- private StringBuffer formatImaginary(double absIm,
- StringBuffer toAppendTo,
- FieldPosition pos) {
- pos.setBeginIndex(0);
- pos.setEndIndex(0);
-
- formatDouble(absIm, getImaginaryFormat(), toAppendTo, pos);
- if (toAppendTo.toString().equals("1")) {
- // Remove the character "1" if it is the only one.
- toAppendTo.setLength(0);
- }
-
- return toAppendTo;
- }
-
- /**
- * Formats a object to produce a string. {@code obj} must be either a
- * {@link Complex} object or a {@link Number} object. Any other type of
- * object will result in an {@link IllegalArgumentException} being thrown.
- *
- * @param obj the object to format.
- * @param toAppendTo where the text is to be appended
- * @param pos On input: an alignment field, if desired. On output: the
- * offsets of the alignment field
- * @return the value passed in as toAppendTo.
- * @see java.text.Format#format(java.lang.Object, java.lang.StringBuffer, java.text.FieldPosition)
- * @throws MathIllegalArgumentException is {@code obj} is not a valid type.
- */
- public StringBuffer format(Object obj, StringBuffer toAppendTo,
- FieldPosition pos) {
-
- StringBuffer ret = null;
-
- if (obj instanceof Complex) {
- ret = format( (Complex)obj, toAppendTo, pos);
- } else if (obj instanceof Number) {
- ret = format(new Complex(((Number)obj).doubleValue(), 0.0),
- toAppendTo, pos);
- } else {
- throw new RuntimeException("Cannot format instance as complex");
- }
-
- return ret;
- }
-
- /**
- * Access the imaginaryCharacter.
- * @return the imaginaryCharacter.
- */
- public String getImaginaryCharacter() {
- return imaginaryCharacter;
- }
-
- /**
- * Access the imaginaryFormat.
- * @return the imaginaryFormat.
- */
- public NumberFormat getImaginaryFormat() {
- return imaginaryFormat;
- }
-
- /**
- * Returns the default complex format for the current locale.
- * @return the default complex format.
- */
- public static ComplexFormat getInstance() {
- return getInstance(Locale.getDefault());
- }
-
- /**
- * Returns the default complex format for the given locale.
- * @param locale the specific locale used by the format.
- * @return the complex format specific to the given locale.
- */
- public static ComplexFormat getInstance(Locale locale) {
- NumberFormat f = getDefaultNumberFormat(locale);
- return new ComplexFormat(f);
- }
-
- /**
- * Returns the default complex format for the given locale.
- * @param locale the specific locale used by the format.
- * @param imaginaryCharacter Imaginary character.
- * @return the complex format specific to the given locale.
- * @throws NullArgumentException if {@code imaginaryCharacter} is
- * {@code null}.
- * @throws NoDataException if {@code imaginaryCharacter} is an
- * empty string.
- */
- public static ComplexFormat getInstance(String imaginaryCharacter, Locale locale) {
- NumberFormat f = getDefaultNumberFormat(locale);
- return new ComplexFormat(imaginaryCharacter, f);
- }
-
- /**
- * Access the realFormat.
- * @return the realFormat.
- */
- public NumberFormat getRealFormat() {
- return realFormat;
- }
-
- /**
- * Parses a string to produce a {@link Complex} object.
- *
- * @param source the string to parse.
- * @return the parsed {@link Complex} object.
- * @throws MathParseException if the beginning of the specified string
- * cannot be parsed.
- */
- public Complex parse(String source) {
- ParsePosition parsePosition = new ParsePosition(0);
- Complex result = parse(source, parsePosition);
- if (parsePosition.getIndex() == 0) {
- throw new RuntimeException("ComplexFormat parse error at index "+ parsePosition.getErrorIndex());
- }
- return result;
- }
-
- /**
- * Parses a string to produce a {@link Complex} object.
- *
- * @param source the string to parse
- * @param pos input/ouput parsing parameter.
- * @return the parsed {@link Complex} object.
- */
- public Complex parse(String source, ParsePosition pos) {
- int initialIndex = pos.getIndex();
-
- // parse whitespace
- parseAndIgnoreWhitespace(source, pos);
-
- // parse real
- Number re = parseNumber(source, getRealFormat(), pos);
- if (re == null) {
- // invalid real number
- // set index back to initial, error index should already be set
- pos.setIndex(initialIndex);
- return null;
- }
-
- // parse sign
- int startIndex = pos.getIndex();
- char c = parseNextCharacter(source, pos);
- int sign = 0;
- switch (c) {
- case 0 :
- // no sign
- // return real only complex number
- return new Complex(re.doubleValue(), 0.0);
- case '-' :
- sign = -1;
- break;
- case '+' :
- sign = 1;
- break;
- default :
- // invalid sign
- // set index back to initial, error index should be the last
- // character examined.
- pos.setIndex(initialIndex);
- pos.setErrorIndex(startIndex);
- return null;
- }
-
- // parse whitespace
- parseAndIgnoreWhitespace(source, pos);
-
- // parse imaginary
- Number im = parseNumber(source, getRealFormat(), pos);
- if (im == null) {
- // invalid imaginary number
- // set index back to initial, error index should already be set
- pos.setIndex(initialIndex);
- return null;
- }
-
- // parse imaginary character
- if (!parseFixedstring(source, getImaginaryCharacter(), pos)) {
- return null;
- }
-
- return new Complex(re.doubleValue(), im.doubleValue() * sign);
-
- }
-
-
- /**
- * Create a default number format. The default number format is based on
- * {@link NumberFormat#getInstance()} with the only customizing that the
- * maximum number of fraction digits is set to 10.
- * @return the default number format.
- */
- public static NumberFormat getDefaultNumberFormat() {
- return getDefaultNumberFormat(Locale.getDefault());
- }
-
- /**
- * Create a default number format. The default number format is based on
- * {@link NumberFormat#getInstance(java.util.Locale)} with the only
- * customizing that the maximum number of fraction digits is set to 10.
- * @param locale the specific locale used by the format.
- * @return the default number format specific to the given locale.
- */
- public static NumberFormat getDefaultNumberFormat(final Locale locale) {
- final NumberFormat nf = NumberFormat.getInstance(locale);
- nf.setMaximumFractionDigits(10);
- return nf;
- }
-
- /**
- * Parses <code>source</code> until a non-whitespace character is found.
- *
- * @param source the string to parse
- * @param pos input/output parsing parameter. On output, <code>pos</code>
- * holds the index of the next non-whitespace character.
- */
- public static void parseAndIgnoreWhitespace(final String source,
- final ParsePosition pos) {
- parseNextCharacter(source, pos);
- pos.setIndex(pos.getIndex() - 1);
- }
-
- /**
- * Parses <code>source</code> until a non-whitespace character is found.
- *
- * @param source the string to parse
- * @param pos input/output parsing parameter.
- * @return the first non-whitespace character.
- */
- public static char parseNextCharacter(final String source,
- final ParsePosition pos) {
- int index = pos.getIndex();
- final int n = source.length();
- char ret = 0;
-
- if (index < n) {
- char c;
- do {
- c = source.charAt(index++);
- } while (Character.isWhitespace(c) && index < n);
- pos.setIndex(index);
-
- if (index < n) {
- ret = c;
- }
- }
-
- return ret;
- }
-
- /**
- * Parses <code>source</code> for special double values. These values
- * include Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY.
- *
- * @param source the string to parse
- * @param value the special value to parse.
- * @param pos input/output parsing parameter.
- * @return the special number.
- */
- private static Number parseNumber(final String source, final double value,
- final ParsePosition pos) {
- Number ret = null;
-
- StringBuilder sb = new StringBuilder();
- sb.append('(');
- sb.append(value);
- sb.append(')');
-
- final int n = sb.length();
- final int startIndex = pos.getIndex();
- final int endIndex = startIndex + n;
- if (endIndex < source.length() &&
- source.substring(startIndex, endIndex).compareTo(sb.toString()) == 0) {
- ret = Double.valueOf(value);
- pos.setIndex(endIndex);
- }
-
- return ret;
- }
-
- /**
- * Parses <code>source</code> for a number. This method can parse normal,
- * numeric values as well as special values. These special values include
- * Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY.
- *
- * @param source the string to parse
- * @param format the number format used to parse normal, numeric values.
- * @param pos input/output parsing parameter.
- * @return the parsed number.
- */
- public static Number parseNumber(final String source, final NumberFormat format,
- final ParsePosition pos) {
- final int startIndex = pos.getIndex();
- Number number = format.parse(source, pos);
- final int endIndex = pos.getIndex();
-
- // check for error parsing number
- if (startIndex == endIndex) {
- // try parsing special numbers
- final double[] special = {
- Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY
- };
- for (int i = 0; i < special.length; ++i) {
- number = parseNumber(source, special[i], pos);
- if (number != null) {
- break;
- }
- }
- }
-
- return number;
- }
-
- /**
- * Parse <code>source</code> for an expected fixed string.
- * @param source the string to parse
- * @param expected expected string
- * @param pos input/output parsing parameter.
- * @return true if the expected string was there
- */
- public static boolean parseFixedstring(final String source,
- final String expected,
- final ParsePosition pos) {
-
- final int startIndex = pos.getIndex();
- final int endIndex = startIndex + expected.length();
- if ((startIndex >= source.length()) ||
- (endIndex > source.length()) ||
- (source.substring(startIndex, endIndex).compareTo(expected) != 0)) {
- // set index back to start, error index should be the start index
- pos.setIndex(startIndex);
- pos.setErrorIndex(startIndex);
- return false;
- }
-
- // the string was here
- pos.setIndex(endIndex);
- return true;
- }
-
- /**
- * Formats a double value to produce a string. In general, the value is
- * formatted using the formatting rules of <code>format</code>. There are
- * three exceptions to this:
- * <ol>
- * <li>NaN is formatted as '(NaN)'</li>
- * <li>Positive infinity is formatted as '(Infinity)'</li>
- * <li>Negative infinity is formatted as '(-Infinity)'</li>
- * </ol>
- *
- * @param value the double to format.
- * @param format the format used.
- * @param toAppendTo where the text is to be appended
- * @param pos On input: an alignment field, if desired. On output: the
- * offsets of the alignment field
- * @return the value passed in as toAppendTo.
- */
- public static StringBuffer formatDouble(final double value, final NumberFormat format,
- final StringBuffer toAppendTo,
- final FieldPosition pos) {
- if( Double.isNaN(value) || Double.isInfinite(value) ) {
- toAppendTo.append('(');
- toAppendTo.append(value);
- toAppendTo.append(')');
- } else {
- format.format(value, toAppendTo, pos);
- }
- return toAppendTo;
- }
-
-
-}
http://git-wip-us.apache.org/repos/asf/commons-numbers/blob/a752ab8d/src/main/java/org/apache/commons/complex/ComplexUtils.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/complex/ComplexUtils.java b/src/main/java/org/apache/commons/complex/ComplexUtils.java
deleted file mode 100644
index 165d907..0000000
--- a/src/main/java/org/apache/commons/complex/ComplexUtils.java
+++ /dev/null
@@ -1,1430 +0,0 @@
-/*
- * 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.complex;
-
-/**
- * Static implementations of common {@link Complex} utilities functions.
- */
-public class ComplexUtils {
-
- /**
- * Utility class.
- */
- private ComplexUtils() {}
-
- /**
- * Creates a complex number from the given polar representation.
- * <p>
- * If either {@code r} or {@code theta} is NaN, or {@code theta} is
- * infinite, {@link Complex#NaN} is returned.
- * <p>
- * If {@code r} is infinite and {@code theta} is finite, infinite or NaN
- * values may be returned in parts of the result, following the rules for
- * double arithmetic.
- *
- * <pre>
- * Examples:
- * {@code
- * polar2Complex(INFINITY, \(\pi\)) = INFINITY + INFINITY i
- * polar2Complex(INFINITY, 0) = INFINITY + NaN i
- * polar2Complex(INFINITY, \(-\frac{\pi}{4}\)) = INFINITY - INFINITY i
- * polar2Complex(INFINITY, \(5\frac{\pi}{4}\)) = -INFINITY - INFINITY i }
- * </pre>
- *
- * @param r the modulus of the complex number to create
- * @param theta the argument of the complex number to create
- * @return {@code Complex}
- * @since 1.1
- */
- public static Complex polar2Complex(double r, double theta) {
- if (r < 0) {
- throw new NegativeModulusException(r);
- }
- return new Complex(r * Math.cos(theta), r * Math.sin(theta));
- }
-
- /**
- * Creates {@code Complex[]} array given {@code double[]} arrays of r and
- * theta.
- *
- * @param r {@code double[]} of moduli
- * @param theta {@code double[]} of arguments
- * @return {@code Complex[]}
- * @since 4.0
- */
- public static Complex[] polar2Complex(double[] r, double[] theta) {
- final int length = r.length;
- final Complex[] c = new Complex[length];
- for (int x = 0; x < length; x++) {
- if (r[x] < 0) {
- throw new NegativeModulusException(r[x]);
- }
- c[x] = new Complex(r[x] * Math.cos(theta[x]), r[x] * Math.sin(theta[x]));
- }
- return c;
- }
-
- /**
- * Creates {@code Complex[][]} array given {@code double[][]} arrays of r
- * and theta.
- *
- * @param r {@code double[]} of moduli
- * @param theta {@code double[]} of arguments
- * @return {@code Complex[][]}
- * @since 4.0
- */
- public static Complex[][] polar2Complex(double[][] r, double[][] theta) {
- final int length = r.length;
- final Complex[][] c = new Complex[length][];
- for (int x = 0; x < length; x++) {
- c[x] = polar2Complex(r[x], theta[x]);
- }
- return c;
- }
-
- /**
- * Creates {@code Complex[][][]} array given {@code double[][][]} arrays of
- * r and theta.
- *
- * @param r array of moduli
- * @param theta array of arguments
- * @return {@code Complex}
- * @since 4.0
- */
- public static Complex[][][] polar2Complex(double[][][] r, double[][][] theta) {
- final int length = r.length;
- final Complex[][][] c = new Complex[length][][];
- for (int x = 0; x < length; x++) {
- c[x] = polar2Complex(r[x], theta[x]);
- }
- return c;
- }
-
- /**
- * Returns double from array {@code real[]} at entry {@code index} as a
- * {@code Complex}.
- *
- * @param real array of real numbers
- * @param index location in the array
- * @return {@code Complex}.
- *
- * @since 4.0
- */
- public static Complex extractComplexFromRealArray(double[] real, int index) {
- return new Complex(real[index]);
- }
-
- /**
- * Returns float from array {@code real[]} at entry {@code index} as a
- * {@code Complex}.
- *
- * @param real array of real numbers
- * @param index location in the array
- * @return {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex extractComplexFromRealArray(float[] real, int index) {
- return new Complex(real[index]);
- }
-
- /**
- * Returns double from array {@code imaginary[]} at entry {@code index} as a
- * {@code Complex}.
- *
- * @param imaginary array of imaginary numbers
- * @param index location in the array
- * @return {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex extractComplexFromImaginaryArray(double[] imaginary, int index) {
- return new Complex(0, imaginary[index]);
- }
-
- /**
- * Returns float from array {@code imaginary[]} at entry {@code index} as a
- * {@code Complex}.
- *
- * @param imaginary array of imaginary numbers
- * @param index location in the array
- * @return {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex extractComplexFromImaginaryArray(float[] imaginary, int index) {
- return new Complex(0, imaginary[index]);
- }
-
- /**
- * Returns real component of Complex from array {@code Complex[]} at entry
- * {@code index} as a {@code double}.
- *
- * @param complex array of complex numbers
- * @param index location in the array
- * @return {@code double}.
- *
- * @since 4.0
- */
- public static double extractRealFromComplexArray(Complex[] complex, int index) {
- return complex[index].getReal();
- }
-
- /**
- * Returns real component of array {@code Complex[]} at entry {@code index}
- * as a {@code float}.
- *
- * @param complex array of complex numbers
- * @param index location in the array
- * @return {@code float}.
- *
- * @since 4.0
- */
- public static float extractRealFloatFromComplexArray(Complex[] complex, int index) {
- return (float) complex[index].getReal();
- }
-
- /**
- * Returns imaginary component of Complex from array {@code Complex[]} at
- * entry {@code index} as a {@code double}.
- *
- * @param complex array of complex numbers
- * @param index location in the array
- * @return {@code double}.
- *
- * @since 4.0
- */
- public static double extractImaginaryFromComplexArray(Complex[] complex, int index) {
- return complex[index].getImaginary();
- }
-
- /**
- * Returns imaginary component of array {@code Complex[]} at entry
- * {@code index} as a {@code float}.
- *
- * @param complex array of complex numbers
- * @param index location in the array
- * @return {@code float}.
- *
- * @since 4.0
- */
- public static float extractImaginaryFloatFromComplexArray(Complex[] complex, int index) {
- return (float) complex[index].getImaginary();
- }
-
- /**
- * Returns a Complex object from interleaved {@code double[]} array at entry
- * {@code index}.
- *
- * @param d array of interleaved complex numbers alternating real and imaginary values
- * @param index location in the array This is the location by complex number, e.g. index number 5 in the array will return {@code new Complex(d[10], d[11])}
- * @return {@code Complex}.
- *
- * @since 4.0
- */
- public static Complex extractComplexFromInterleavedArray(double[] d, int index) {
- return new Complex(d[index * 2], d[index * 2 + 1]);
- }
-
- /**
- * Returns a Complex object from interleaved {@code float[]} array at entry
- * {@code index}.
- *
- * @param f float array of interleaved complex numbers alternating real and imaginary values
- * @param index location in the array This is the location by complex number, e.g. index number 5 in the {@code float[]} array will return new {@code Complex(d[10], d[11])}
- * @return {@code Complex}.
- *
- * @since 4.0
- */
- public static Complex extractComplexFromInterleavedArray(float[] f, int index) {
- return new Complex(f[index * 2], f[index * 2 + 1]);
- }
-
- /**
- * Returns values of Complex object from array {@code Complex[]} at entry
- * {@code index} as a size 2 {@code double} of the form {real, imag}.
- *
- * @param complex array of complex numbers
- * @param index location in the array
- * @return size 2 array.
- *
- * @since 4.0
- */
- public static double[] extractInterleavedFromComplexArray(Complex[] complex, int index) {
- return new double[] { complex[index].getReal(), complex[index].getImaginary() };
- }
-
- /**
- * Returns Complex object from array {@code Complex[]} at entry
- * {@code index} as a size 2 {@code float} of the form {real, imag}.
- *
- * @param complex {@code Complex} array
- * @param index location in the array
- * @return size 2 {@code float[]}.
- *
- * @since 4.0
- */
- public static float[] extractInterleavedFloatFromComplexArray(Complex[] complex, int index) {
- return new float[] { (float) complex[index].getReal(), (float) complex[index].getImaginary() };
- }
-
- /**
- * Converts a {@code double[]} array to a {@code Complex[]} array.
- *
- * @param real array of numbers to be converted to their {@code Complex} equivalent
- * @return {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[] real2Complex(double[] real) {
- int index = 0;
- final Complex c[] = new Complex[real.length];
- for (double d : real) {
- c[index] = new Complex(d);
- index++;
- }
- return c;
- }
-
- /**
- * Converts a {@code float[]} array to a {@code Complex[]} array.
- *
- * @param real array of numbers to be converted to their {@code Complex} equivalent
- * @return {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[] real2Complex(float[] real) {
- int index = 0;
- final Complex c[] = new Complex[real.length];
- for (float d : real) {
- c[index] = new Complex(d);
- index++;
- }
- return c;
- }
-
- /**
- * Converts a 2D real {@code double[][]} array to a 2D {@code Complex[][]}
- * array.
- *
- * @param d 2D array
- * @return 2D {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[][] real2Complex(double[][] d) {
- final int width = d.length;
- final Complex[][] c = new Complex[width][];
- for (int n = 0; n < width; n++) {
- c[n] = ComplexUtils.real2Complex(d[n]);
- }
- return c;
- }
-
- /**
- * Converts a 3D real {@code double[][][]} array to a {@code Complex [][][]}
- * array.
- *
- * @param d 3D complex interleaved array
- * @return 3D {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[][][] real2Complex(double[][][] d) {
- final int width = d.length;
- final Complex[][][] c = new Complex[width][][];
- for (int x = 0; x < width; x++) {
- c[x] = ComplexUtils.real2Complex(d[x]);
- }
- return c;
- }
-
- /**
- * Converts real component of {@code Complex[]} array to a {@code double[]}
- * array.
- *
- * @param c {@code Complex} array
- * @return array of the real component
- *
- * @since 4.0
- */
- public static double[] complex2Real(Complex[] c) {
- int index = 0;
- final double d[] = new double[c.length];
- for (Complex cc : c) {
- d[index] = cc.getReal();
- index++;
- }
- return d;
- }
-
- /**
- * Converts real component of {@code Complex[]} array to a {@code float[]}
- * array.
- *
- * @param c {@code Complex} array
- * @return {@code float[]} array of the real component
- *
- * @since 4.0
- */
- public static float[] complex2RealFloat(Complex[] c) {
- int index = 0;
- final float f[] = new float[c.length];
- for (Complex cc : c) {
- f[index] = (float) cc.getReal();
- index++;
- }
- return f;
- }
-
- /**
- * Converts real component of a 2D {@code Complex[][]} array to a 2D
- * {@code double[][]} array.
- *
- * @param c 2D {@code Complex} array
- * @return {@code double[][]} of real component
- * @since 4.0
- */
- public static double[][] complex2Real(Complex[][] c) {
- final int length = c.length;
- double[][] d = new double[length][];
- for (int n = 0; n < length; n++) {
- d[n] = complex2Real(c[n]);
- }
- return d;
- }
-
- /**
- * Converts real component of a 2D {@code Complex[][]} array to a 2D
- * {@code float[][]} array.
- *
- * @param c 2D {@code Complex} array
- * @return {@code float[][]} of real component
- * @since 4.0
- */
- public static float[][] complex2RealFloat(Complex[][] c) {
- final int length = c.length;
- float[][] f = new float[length][];
- for (int n = 0; n < length; n++) {
- f[n] = complex2RealFloat(c[n]);
- }
- return f;
- }
-
- /**
- * Converts real component of a 3D {@code Complex[][][]} array to a 3D
- * {@code double[][][]} array.
- *
- * @param c 3D complex interleaved array
- * @return array of real component
- *
- * @since 4.0
- */
- public static double[][][] complex2Real(Complex[][][] c) {
- final int length = c.length;
- double[][][] d = new double[length][][];
- for (int n = 0; n < length; n++) {
- d[n] = complex2Real(c[n]);
- }
- return d;
- }
-
- /**
- * Converts real component of a 3D {@code Complex[][][]} array to a 3D
- * {@code float[][][]} array.
- *
- * @param c 3D {@code Complex} array
- * @return {@code float[][][]} of real component
- * @since 4.0
- */
- public static float[][][] complex2RealFloat(Complex[][][] c) {
- final int length = c.length;
- float[][][] f = new float[length][][];
- for (int n = 0; n < length; n++) {
- f[n] = complex2RealFloat(c[n]);
- }
- return f;
- }
-
- /**
- * Converts a {@code double[]} array to an imaginary {@code Complex[]}
- * array.
- *
- * @param imaginary array of numbers to be converted to their {@code Complex} equivalent
- * @return {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[] imaginary2Complex(double[] imaginary) {
- int index = 0;
- final Complex c[] = new Complex[imaginary.length];
- for (double d : imaginary) {
- c[index] = new Complex(0, d);
- index++;
- }
- return c;
- }
-
- /**
- * Converts a {@code float[]} array to an imaginary {@code Complex[]} array.
- *
- * @param imaginary array of numbers to be converted to their {@code Complex} equivalent
- * @return {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[] imaginary2Complex(float[] imaginary) {
- int index = 0;
- final Complex c[] = new Complex[imaginary.length];
- for (float d : imaginary) {
- c[index] = new Complex(0, d);
- index++;
- }
- return c;
- }
-
- /**
- * Converts a 2D imaginary array {@code double[][]} to a 2D
- * {@code Complex[][]} array.
- *
- * @param d 2D array
- * @return 2D {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[][] imaginary2Complex(double[][] d) {
- int width = d.length;
- int height = d[0].length;
- Complex[][] c = new Complex[width][height];
- for (int n = 0; n < width; n++) {
- c[n] = ComplexUtils.imaginary2Complex(d[n]);
- }
- return c;
- }
-
- /**
- * Converts a 3D imaginary array {@code double[][][]} to a {@code Complex[]}
- * array.
- *
- * @param d 3D complex imaginary array
- * @return 3D {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[][][] imaginary2Complex(double[][][] d) {
- int width = d.length;
- int height = d[0].length;
- int depth = d[0].length;
- Complex[][][] c = new Complex[width][height][depth];
- for (int x = 0; x < width; x++) {
- for (int y = 0; y < height; y++) {
- c[x][y] = ComplexUtils.imaginary2Complex(d[x][y]);
- }
- }
- return c;
- }
-
- /**
- * Converts imaginary part of a {@code Complex[]} array to a
- * {@code double[]} array.
- *
- * @param c {@code Complex} array.
- * @return array of the imaginary component
- *
- * @since 4.0
- */
- public static double[] complex2Imaginary(Complex[] c) {
- int index = 0;
- final double d[] = new double[c.length];
- for (Complex cc : c) {
- d[index] = cc.getImaginary();
- index++;
- }
- return d;
- }
-
- /**
- * Converts imaginary component of a {@code Complex[]} array to a
- * {@code float[]} array.
- *
- * @param c {@code Complex} array.
- * @return {@code float[]} array of the imaginary component
- *
- * @since 4.0
- */
- public static float[] complex2ImaginaryFloat(Complex[] c) {
- int index = 0;
- final float f[] = new float[c.length];
- for (Complex cc : c) {
- f[index] = (float) cc.getImaginary();
- index++;
- }
- return f;
- }
-
- /**
- * Converts imaginary component of a 2D {@code Complex[][]} array to a 2D
- * {@code double[][]} array.
- *
- * @param c 2D {@code Complex} array
- * @return {@code double[][]} of imaginary component
- * @since 4.0
- */
- public static double[][] complex2Imaginary(Complex[][] c) {
- final int length = c.length;
- double[][] d = new double[length][];
- for (int n = 0; n < length; n++) {
- d[n] = complex2Imaginary(c[n]);
- }
- return d;
- }
-
- /**
- * Converts imaginary component of a 2D {@code Complex[][]} array to a 2D
- * {@code float[][]} array.
- *
- * @param c 2D {@code Complex} array
- * @return {@code float[][]} of imaginary component
- * @since 4.0
- */
- public static float[][] complex2ImaginaryFloat(Complex[][] c) {
- final int length = c.length;
- float[][] f = new float[length][];
- for (int n = 0; n < length; n++) {
- f[n] = complex2ImaginaryFloat(c[n]);
- }
- return f;
- }
-
- /**
- * Converts imaginary component of a 3D {@code Complex[][][]} array to a 3D
- * {@code double[][][]} array.
- *
- * @param c 3D complex interleaved array
- * @return 3D {@code Complex} array
- *
- * @since 4.0
- */
- public static double[][][] complex2Imaginary(Complex[][][] c) {
- final int length = c.length;
- double[][][] d = new double[length][][];
- for (int n = 0; n < length; n++) {
- d[n] = complex2Imaginary(c[n]);
- }
- return d;
- }
-
- /**
- * Converts imaginary component of a 3D {@code Complex[][][]} array to a 3D
- * {@code float[][][]} array.
- *
- * @param c 3D {@code Complex} array
- * @return {@code float[][][]} of imaginary component
- * @since 4.0
- */
- public static float[][][] complex2ImaginaryFloat(Complex[][][] c) {
- final int length = c.length;
- float[][][] f = new float[length][][];
- for (int n = 0; n < length; n++) {
- f[n] = complex2ImaginaryFloat(c[n]);
- }
- return f;
- }
-
- // INTERLEAVED METHODS
-
- /**
- * Converts a complex interleaved {@code double[]} array to a
- * {@code Complex[]} array
- *
- * @param interleaved array of numbers to be converted to their {@code Complex} equivalent
- * @return {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[] interleaved2Complex(double[] interleaved) {
- final int length = interleaved.length / 2;
- final Complex c[] = new Complex[length];
- for (int n = 0; n < length; n++) {
- c[n] = new Complex(interleaved[n * 2], interleaved[n * 2 + 1]);
- }
- return c;
- }
-
- /**
- * Converts a complex interleaved {@code float[]} array to a
- * {@code Complex[]} array
- *
- * @param interleaved float[] array of numbers to be converted to their {@code Complex} equivalent
- * @return {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[] interleaved2Complex(float[] interleaved) {
- final int length = interleaved.length / 2;
- final Complex c[] = new Complex[length];
- for (int n = 0; n < length; n++) {
- c[n] = new Complex(interleaved[n * 2], interleaved[n * 2 + 1]);
- }
- return c;
- }
-
- /**
- * Converts a {@code Complex[]} array to an interleaved complex
- * {@code double[]} array
- *
- * @param c Complex array
- * @return complex interleaved array alternating real and
- * imaginary values
- *
- * @since 4.0
- */
- public static double[] complex2Interleaved(Complex[] c) {
- int index = 0;
- final double d[] = new double[c.length * 2];
- for (Complex cc : c) {
- int real = index * 2;
- int imag = index * 2 + 1;
- d[real] = cc.getReal();
- d[imag] = cc.getImaginary();
- index++;
- }
- return d;
- }
-
- /**
- * Converts a {@code Complex[]} array to an interleaved complex
- * {@code float[]} array
- *
- * @param c Complex array
- * @return complex interleaved {@code float[]} alternating real and
- * imaginary values
- *
- * @since 4.0
- */
- public static float[] complex2InterleavedFloat(Complex[] c) {
- int index = 0;
- final float f[] = new float[c.length * 2];
- for (Complex cc : c) {
- int real = index * 2;
- int imag = index * 2 + 1;
- f[real] = (float) cc.getReal();
- f[imag] = (float) cc.getImaginary();
- index++;
- }
- return f;
- }
-
- /**
- * Converts a 2D {@code Complex[][]} array to an interleaved complex
- * {@code double[][]} array.
- *
- * @param c 2D Complex array
- * @param interleavedDim Depth level of the array to interleave
- * @return complex interleaved array alternating real and
- * imaginary values
- *
- * @since 4.0
- */
- public static double[][] complex2Interleaved(Complex[][] c, int interleavedDim) {
- if (interleavedDim > 1 || interleavedDim < 0) {
- new IndexOutOfRangeException(interleavedDim);
- }
- final int width = c.length;
- final int height = c[0].length;
- double[][] d;
- if (interleavedDim == 0) {
- d = new double[2 * width][height];
- for (int x = 0; x < width; x++) {
- for (int y = 0; y < height; y++) {
- d[x * 2][y] = c[x][y].getReal();
- d[x * 2 + 1][y] = c[x][y].getImaginary();
- }
- }
- } else {
- d = new double[width][2 * height];
- for (int x = 0; x < width; x++) {
- for (int y = 0; y < height; y++) {
- d[x][y * 2] = c[x][y].getReal();
- d[x][y * 2 + 1] = c[x][y].getImaginary();
- }
- }
- }
- return d;
- }
-
- /**
- * Converts a 2D {@code Complex[][]} array to an interleaved complex
- * {@code double[][]} array. The second depth level of the array is assumed
- * to be interleaved.
- *
- * @param c 2D Complex array
- * @return complex interleaved array alternating real and
- * imaginary values
- *
- * @since 4.0
- */
- public static double[][] complex2Interleaved(Complex[][] c) {
- return complex2Interleaved(c, 1);
- }
-
- /**
- * Converts a 3D {@code Complex[][][]} array to an interleaved complex
- * {@code double[][][]} array.
- *
- * @param c 3D Complex array
- * @param interleavedDim Depth level of the array to interleave
- * @return complex interleaved array alternating real and
- * imaginary values
- *
- * @since 4.0
- */
- public static double[][][] complex2Interleaved(Complex[][][] c, int interleavedDim) {
- if (interleavedDim > 2 || interleavedDim < 0) {
- new IndexOutOfRangeException(interleavedDim);
- }
- int width = c.length;
- int height = c[0].length;
- int depth = c[0][0].length;
- double[][][] d;
- if (interleavedDim == 0) {
- d = new double[2 * width][height][depth];
- for (int x = 0; x < width; x++) {
- for (int y = 0; y < height; y++) {
- for (int z = 0; z < depth; z++) {
- d[x * 2][y][z] = c[x][y][z].getReal();
- d[x * 2 + 1][y][z] = c[x][y][z].getImaginary();
- }
- }
- }
- } else if (interleavedDim == 1) {
- d = new double[width][2 * height][depth];
- for (int x = 0; x < width; x++) {
- for (int y = 0; y < height; y++) {
- for (int z = 0; z < depth; z++) {
- d[x][y * 2][z] = c[x][y][z].getReal();
- d[x][y * 2 + 1][z] = c[x][y][z].getImaginary();
- }
- }
- }
- } else {
- d = new double[width][height][2 * depth];
- for (int x = 0; x < width; x++) {
- for (int y = 0; y < height; y++) {
- for (int z = 0; z < depth; z++) {
- d[x][y][z * 2] = c[x][y][z].getReal();
- d[x][y][z * 2 + 1] = c[x][y][z].getImaginary();
- }
- }
- }
- }
- return d;
- }
-
- /**
- * Converts a 3D {@code Complex[][][]} array to an interleaved complex
- * {@code double[][][]} array. The third depth level of the array is
- * interleaved.
- *
- * @param c 3D Complex array
- * @return complex interleaved array alternating real and
- * imaginary values
- *
- * @since 4.0
- */
- public static double[][][] complex2Interleaved(Complex[][][] c) {
- return complex2Interleaved(c, 2);
- }
-
- /**
- * Converts a 2D {@code Complex[][]} array to an interleaved complex
- * {@code float[][]} array.
- *
- * @param c 2D Complex array
- * @param interleavedDim Depth level of the array to interleave
- * @return complex interleaved {@code float[][]} alternating real and
- * imaginary values
- *
- * @since 4.0
- */
- public static float[][] complex2InterleavedFloat(Complex[][] c, int interleavedDim) {
- if (interleavedDim > 1 || interleavedDim < 0) {
- new IndexOutOfRangeException(interleavedDim);
- }
- final int width = c.length;
- final int height = c[0].length;
- float[][] d;
- if (interleavedDim == 0) {
- d = new float[2 * width][height];
- for (int x = 0; x < width; x++) {
- for (int y = 0; y < height; y++) {
- d[x * 2][y] = (float) c[x][y].getReal();
- d[x * 2 + 1][y] = (float) c[x][y].getImaginary();
- }
- }
- } else {
- d = new float[width][2 * height];
- for (int x = 0; x < width; x++) {
- for (int y = 0; y < height; y++) {
- d[x][y * 2] = (float) c[x][y].getReal();
- d[x][y * 2 + 1] = (float) c[x][y].getImaginary();
- }
- }
- }
- return d;
- }
-
- /**
- * Converts a 2D {@code Complex[][]} array to an interleaved complex
- * {@code float[][]} array. The second depth level of the array is assumed
- * to be interleaved.
- *
- * @param c 2D Complex array
- *
- * @return complex interleaved {@code float[][]} alternating real and
- * imaginary values
- *
- * @since 4.0
- */
- public static float[][] complex2InterleavedFloat(Complex[][] c) {
- return complex2InterleavedFloat(c, 1);
- }
-
- /**
- * Converts a 3D {@code Complex[][][]} array to an interleaved complex
- * {@code float[][][]} array.
- *
- * @param c 3D Complex array
- * @param interleavedDim Depth level of the array to interleave
- * @return complex interleaved {@code float[][][]} alternating real and
- * imaginary values
- *
- * @since 4.0
- */
- public static float[][][] complex2InterleavedFloat(Complex[][][] c, int interleavedDim) {
- if (interleavedDim > 2 || interleavedDim < 0) {
- new IndexOutOfRangeException(interleavedDim);
- }
- final int width = c.length;
- final int height = c[0].length;
- final int depth = c[0][0].length;
- float[][][] d;
- if (interleavedDim == 0) {
- d = new float[2 * width][height][depth];
- for (int x = 0; x < width; x++) {
- for (int y = 0; y < height; y++) {
- for (int z = 0; z < depth; z++) {
- d[x * 2][y][z] = (float) c[x][y][z].getReal();
- d[x * 2 + 1][y][z] = (float) c[x][y][z].getImaginary();
- }
- }
- }
- } else if (interleavedDim == 1) {
- d = new float[width][2 * height][depth];
- for (int x = 0; x < width; x++) {
- for (int y = 0; y < height; y++) {
- for (int z = 0; z < depth; z++) {
- d[x][y * 2][z] = (float) c[x][y][z].getReal();
- d[x][y * 2 + 1][z] = (float) c[x][y][z].getImaginary();
- }
- }
- }
- } else {
- d = new float[width][height][2 * depth];
- for (int x = 0; x < width; x++) {
- for (int y = 0; y < height; y++) {
- for (int z = 0; z < depth; z++) {
- d[x][y][z * 2] = (float) c[x][y][z].getReal();
- d[x][y][z * 2 + 1] = (float) c[x][y][z].getImaginary();
- }
- }
- }
- }
- return d;
- }
-
- /**
- * Converts a 3D {@code Complex[][][]} array to an interleaved complex
- * {@code float[][][]} array. The third depth level of the array is
- * interleaved.
- *
- * @param c 2D Complex array
- *
- * @return complex interleaved {@code float[][][]} alternating real and
- * imaginary values
- *
- * @since 4.0
- */
- public static float[][][] complex2InterleavedFloat(Complex[][][] c) {
- return complex2InterleavedFloat(c, 2);
- }
-
- /**
- * Converts a 2D interleaved complex {@code double[][]} array to a
- * {@code Complex[][]} array.
- *
- * @param d 2D complex interleaved array
- * @param interleavedDim Depth level of the array to interleave
- * @return 2D {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[][] interleaved2Complex(double[][] d, int interleavedDim) {
- if (interleavedDim > 1 || interleavedDim < 0) {
- new IndexOutOfRangeException(interleavedDim);
- }
- final int width = d.length;
- final int height = d[0].length;
- Complex[][] c;
- if (interleavedDim == 0) {
- c = new Complex[width / 2][height];
- for (int x = 0; x < width / 2; x++) {
- for (int y = 0; y < height; y++) {
- c[x][y] = new Complex(d[x * 2][y], d[x * 2 + 1][y]);
- }
- }
- } else {
- c = new Complex[width][height / 2];
- for (int x = 0; x < width; x++) {
- for (int y = 0; y < height / 2; y++) {
- c[x][y] = new Complex(d[x][y * 2], d[x][y * 2 + 1]);
- }
- }
- }
- return c;
- }
-
- /**
- * Converts a 2D interleaved complex {@code double[][]} array to a
- * {@code Complex[][]} array. The second depth level of the array is assumed
- * to be interleaved.
- *
- * @param d 2D complex interleaved array
- * @return 2D {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[][] interleaved2Complex(double[][] d) {
- return interleaved2Complex(d, 1);
- }
-
- /**
- * Converts a 3D interleaved complex {@code double[][][]} array to a
- * {@code Complex[][][]} array.
- *
- * @param d 3D complex interleaved array
- * @param interleavedDim Depth level of the array to interleave
- * @return 3D {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[][][] interleaved2Complex(double[][][] d, int interleavedDim) {
- if (interleavedDim > 2 || interleavedDim < 0) {
- new IndexOutOfRangeException(interleavedDim);
- }
- final int width = d.length;
- final int height = d[0].length;
- final int depth = d[0][0].length;
- Complex[][][] c;
- if (interleavedDim == 0) {
- c = new Complex[width / 2][height][depth];
- for (int x = 0; x < width / 2; x++) {
- for (int y = 0; y < height; y++) {
- for (int z = 0; z < depth; z++) {
- c[x][y][z] = new Complex(d[x * 2][y][z], d[x * 2 + 1][y][z]);
- }
- }
- }
- } else if (interleavedDim == 1) {
- c = new Complex[width][height / 2][depth];
- for (int x = 0; x < width; x++) {
- for (int y = 0; y < height / 2; y++) {
- for (int z = 0; z < depth; z++) {
- c[x][y][z] = new Complex(d[x][y * 2][z], d[x][y * 2 + 1][z]);
- }
- }
- }
- } else {
- c = new Complex[width][height][depth / 2];
- for (int x = 0; x < width; x++) {
- for (int y = 0; y < height; y++) {
- for (int z = 0; z < depth / 2; z++) {
- c[x][y][z] = new Complex(d[x][y][z * 2], d[x][y][z * 2 + 1]);
- }
- }
- }
- }
- return c;
- }
-
- /**
- * Converts a 3D interleaved complex {@code double[][][]} array to a
- * {@code Complex[][][]} array. The third depth level is assumed to be
- * interleaved.
- *
- * @param d 3D complex interleaved array
- * @return 3D {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[][][] interleaved2Complex(double[][][] d) {
- return interleaved2Complex(d, 2);
- }
-
- /**
- * Converts a 2D interleaved complex {@code float[][]} array to a
- * {@code Complex[][]} array.
- *
- * @param d 2D complex interleaved float array
- * @param interleavedDim Depth level of the array to interleave
- * @return 2D {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[][] interleaved2Complex(float[][] d, int interleavedDim) {
- if (interleavedDim > 1 || interleavedDim < 0) {
- new IndexOutOfRangeException(interleavedDim);
- }
- final int width = d.length;
- final int height = d[0].length;
- Complex[][] c;
- if (interleavedDim == 0) {
- c = new Complex[width / 2][height];
- for (int x = 0; x < width / 2; x++) {
- for (int y = 0; y < height; y++) {
- c[x][y] = new Complex(d[x * 2][y], d[x * 2 + 1][y]);
- }
- }
- } else {
- c = new Complex[width][height / 2];
- for (int x = 0; x < width; x++) {
- for (int y = 0; y < height / 2; y++) {
- c[x][y] = new Complex(d[x][y * 2], d[x][y * 2 + 1]);
- }
- }
- }
- return c;
- }
-
- /**
- * Converts a 2D interleaved complex {@code float[][]} array to a
- * {@code Complex[][]} array. The second depth level of the array is assumed
- * to be interleaved.
- *
- * @param d 2D complex interleaved float array
- * @return 2D {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[][] interleaved2Complex(float[][] d) {
- return interleaved2Complex(d, 1);
- }
-
- /**
- * Converts a 3D interleaved complex {@code float[][][]} array to a
- * {@code Complex[][][]} array.
- *
- * @param d 3D complex interleaved float array
- * @param interleavedDim Depth level of the array to interleave
- * @return 3D {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[][][] interleaved2Complex(float[][][] d, int interleavedDim) {
- if (interleavedDim > 2 || interleavedDim < 0) {
- new IndexOutOfRangeException(interleavedDim);
- }
- final int width = d.length;
- final int height = d[0].length;
- final int depth = d[0][0].length;
- Complex[][][] c;
- if (interleavedDim == 0) {
- c = new Complex[width / 2][height][depth];
- for (int x = 0; x < width/2; x ++) {
- for (int y = 0; y < height; y++) {
- for (int z = 0; z < depth; z++) {
- c[x][y][z] = new Complex(d[x * 2][y][z], d[x * 2 + 1][y][z]);
- }
- }
- }
- } else if (interleavedDim == 1) {
- c = new Complex[width][height / 2][depth];
- for (int x = 0; x < width; x++) {
- for (int y = 0; y < height/2; y ++) {
- for (int z = 0; z < depth; z++) {
- c[x][y][z] = new Complex(d[x][y * 2][z], d[x][y * 2 + 1][z]);
- }
- }
- }
- } else {
- c = new Complex[width][height][depth / 2];
- for (int x = 0; x < width; x++) {
- for (int y = 0; y < height; y++) {
- for (int z = 0; z < depth/2; z++) {
- c[x][y][z] = new Complex(d[x][y][z * 2], d[x][y][z * 2 + 1]);
- }
- }
- }
- }
- return c;
- }
-
- /**
- * Converts a 3D interleaved complex {@code float[][][]} array to a
- * {@code Complex[]} array. The third depth level of the array is assumed to
- * be interleaved.
- *
- * @param d 3D complex interleaved float array
- * @return 3D {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[][][] interleaved2Complex(float[][][] d) {
- return interleaved2Complex(d, 2);
- }
-
- // SPLIT METHODS
-
- /**
- * Converts a split complex array {@code double[] r, double[] i} to a
- * {@code Complex[]} array.
- *
- * @param real real component
- * @param imag imaginary component
- * @return {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[] split2Complex(double[] real, double[] imag) {
- final int length = real.length;
- final Complex[] c = new Complex[length];
- for (int n = 0; n < length; n++) {
- c[n] = new Complex(real[n], imag[n]);
- }
- return c;
- }
-
- /**
- * Converts a 2D split complex array {@code double[][] r, double[][] i} to a
- * 2D {@code Complex[][]} array.
- *
- * @param real real component
- * @param imag imaginary component
- * @return 2D {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[][] split2Complex(double[][] real, double[][] imag) {
- final int length = real.length;
- Complex[][] c = new Complex[length][];
- for (int x = 0; x < length; x++) {
- c[x] = split2Complex(real[x], imag[x]);
- }
- return c;
- }
-
- /**
- * Converts a 3D split complex array {@code double[][][] r, double[][][] i}
- * to a 3D {@code Complex[][][]} array.
- *
- * @param real real component
- * @param imag imaginary component
- * @return 3D {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[][][] split2Complex(double[][][] real, double[][][] imag) {
- final int length = real.length;
- Complex[][][] c = new Complex[length][][];
- for (int x = 0; x < length; x++) {
- c[x] = split2Complex(real[x], imag[x]);
- }
- return c;
- }
-
- /**
- * Converts a split complex array {@code float[] r, float[] i} to a
- * {@code Complex[]} array.
- *
- * @param real real component
- * @param imag imaginary component
- * @return {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[] split2Complex(float[] real, float[] imag) {
- final int length = real.length;
- final Complex[] c = new Complex[length];
- for (int n = 0; n < length; n++) {
- c[n] = new Complex(real[n], imag[n]);
- }
- return c;
- }
-
- /**
- * Converts a 2D split complex array {@code float[][] r, float[][] i} to a
- * 2D {@code Complex[][]} array.
- *
- * @param real real component
- * @param imag imaginary component
- * @return 2D {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[][] split2Complex(float[][] real, float[][] imag) {
- final int length = real.length;
- Complex[][] c = new Complex[length][];
- for (int x = 0; x < length; x++) {
- c[x] = split2Complex(real[x], imag[x]);
- }
- return c;
- }
-
- /**
- * Converts a 3D split complex array {@code float[][][] r, float[][][] i} to
- * a 3D {@code Complex[][][]} array.
- *
- * @param real real component
- * @param imag imaginary component
- * @return 3D {@code Complex} array
- *
- * @since 4.0
- */
- public static Complex[][][] split2Complex(float[][][] real, float[][][] imag) {
- final int length = real.length;
- Complex[][][] c = new Complex[length][][];
- for (int x = 0; x < length; x++) {
- c[x] = split2Complex(real[x], imag[x]);
- }
- return c;
- }
-
- // MISC
-
- /**
- * Initializes a {@code Complex[]} array to zero, to avoid
- * NullPointerExceptions.
- *
- * @param c Complex array
- * @return c
- *
- * @since 4.0
- */
- public static Complex[] initialize(Complex[] c) {
- final int length = c.length;
- for (int x = 0; x < length; x++) {
- c[x] = Complex.ZERO;
- }
- return c;
- }
-
- /**
- * Initializes a {@code Complex[][]} array to zero, to avoid
- * NullPointerExceptions.
- *
- * @param c {@code Complex} array
- * @return c
- *
- * @since 4.0
- */
- public static Complex[][] initialize(Complex[][] c) {
- final int length = c.length;
- for (int x = 0; x < length; x++) {
- c[x] = initialize(c[x]);
- }
- return c;
- }
-
- /**
- * Initializes a {@code Complex[][][]} array to zero, to avoid
- * NullPointerExceptions.
- *
- * @param c {@code Complex} array
- * @return c
- *
- * @since 4.0
- */
- public static Complex[][][] initialize(Complex[][][] c) {
- final int length = c.length;
- for (int x = 0; x < length; x++) {
- c[x] = initialize(c[x]);
- }
- return c;
- }
-
- /**
- * Returns {@code double[]} containing absolute values (magnitudes) of a
- * {@code Complex[]} array.
- *
- * @param c {@code Complex} array
- * @return {@code double[]}
- *
- * @since 4.0
- */
- public static double[] abs(Complex[] c) {
- final int length = c.length;
- final double[] d = new double[length];
- for (int x = 0; x < length; x++) {
- d[x] = c[x].abs();
- }
- return d;
- }
-
- /**
- * Returns {@code double[]} containing arguments (phase angles) of a
- * {@code Complex[]} array.
- *
- * @param c {@code Complex} array
- * @return {@code double[]} array
- *
- * @since 4.0
- */
- public static double[] arg(Complex[] c) {
- final int length = c.length;
- final double[] d = new double[length];
- for (int x = 0; x < length; x++) {
- d[x] = c[x].getArgument();
- }
- return d;
- }
-
- /**
- * Exception to be throw when a negative value is passed as the modulus.
- */
- private static class NegativeModulusException extends IllegalArgumentException {
- /**
- * @param r Wrong modulus.
- */
- NegativeModulusException(double r) {
- super("Modulus is negative: " + r);
- }
- }
-
- /**
- * Exception to be throw when an out-of-range index value is passed.
- */
- private static class IndexOutOfRangeException extends IllegalArgumentException {
- /**
- * @param i Wrong index.
- */
- IndexOutOfRangeException(int i) {
- super("Out of range: " + i);
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/commons-numbers/blob/a752ab8d/src/main/java/org/apache/commons/complex/Precision.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/complex/Precision.java b/src/main/java/org/apache/commons/complex/Precision.java
deleted file mode 100644
index 77f5048..0000000
--- a/src/main/java/org/apache/commons/complex/Precision.java
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * 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.complex;
-
-/**
- * Utilities for comparing numbers.
- */
-class Precision {
- /** Offset to order signed double numbers lexicographically. */
- private static final long SGN_MASK = 0x8000000000000000L;
- /** Positive zero bits. */
- private static final long POSITIVE_ZERO_DOUBLE_BITS = Double.doubleToRawLongBits(+0.0);
- /** Negative zero bits. */
- private static final long NEGATIVE_ZERO_DOUBLE_BITS = Double.doubleToRawLongBits(-0.0);
-
- /**
- * Private constructor.
- */
- private Precision() {}
-
- /**
- * Returns {@code true} if 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.
- * @param y Second value.
- * @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.
- */
- public static boolean equals(double x, double y, double eps) {
- return equals(x, y, 1) || Math.abs(y - x) <= eps;
- }
-
- /**
- * Returns {@code true} if there is no double value strictly between the
- * arguments or the relative difference between them is less than or equal
- * to the given tolerance. Returns {@code false} if either of the arguments
- * is NaN.
- *
- * @param x First value.
- * @param y Second value.
- * @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.
- */
- public static boolean equalsWithRelativeTolerance(double x, double y, double eps) {
- if (equals(x, y, 1)) {
- return true;
- }
-
- final double absoluteMax = Math.max(Math.abs(x), Math.abs(y));
- final double relativeDifference = Math.abs((x - y) / absoluteMax);
-
- return relativeDifference <= eps;
- }
-
- /**
- * Returns true if the arguments are equal or within the range of allowed
- * error (inclusive).
- * <p>
- * Two float numbers are considered equal if there are {@code (maxUlps - 1)}
- * (or fewer) floating point numbers between them, i.e. two adjacent
- * floating point numbers are considered equal.
- * </p>
- * <p>
- * Adapted from <a
- * href="http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/">
- * Bruce Dawson</a>. Returns {@code false} if either of the arguments is NaN.
- * </p>
- *
- * @param x first value
- * @param y second value
- * @param maxUlps {@code (maxUlps - 1)} is the number of floating point
- * values between {@code x} and {@code y}.
- * @return {@code true} if there are fewer than {@code maxUlps} floating
- * point values between {@code x} and {@code y}.
- */
- public static boolean equals(final double x, final double y, final int maxUlps) {
-
- final long xInt = Double.doubleToRawLongBits(x);
- final long yInt = Double.doubleToRawLongBits(y);
-
- final boolean isEqual;
- if (((xInt ^ yInt) & SGN_MASK) == 0l) {
- // number have same sign, there is no risk of overflow
- isEqual = Math.abs(xInt - yInt) <= maxUlps;
- } else {
- // number have opposite signs, take care of overflow
- final long deltaPlus;
- final long deltaMinus;
- if (xInt < yInt) {
- deltaPlus = yInt - POSITIVE_ZERO_DOUBLE_BITS;
- deltaMinus = xInt - NEGATIVE_ZERO_DOUBLE_BITS;
- } else {
- deltaPlus = xInt - POSITIVE_ZERO_DOUBLE_BITS;
- deltaMinus = yInt - NEGATIVE_ZERO_DOUBLE_BITS;
- }
-
- if (deltaPlus > maxUlps) {
- isEqual = false;
- } else {
- isEqual = deltaMinus <= (maxUlps - deltaPlus);
- }
-
- }
-
- return isEqual && !Double.isNaN(x) && !Double.isNaN(y);
-
- }
-}