Java Code Examples for org.apache.commons.math3.exception.util.LocalizedFormats#FIRST_ELEMENT_NOT_ZERO
The following examples show how to use
org.apache.commons.math3.exception.util.LocalizedFormats#FIRST_ELEMENT_NOT_ZERO .
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
| Source File: FastSineTransformer.java From astor with GNU General Public License v2.0 | 4 votes |
|
/**
* Perform the FST algorithm (including inverse). The first element of the
* data set is required to be {@code 0}.
*
* @param f the real data array to be transformed
* @return the real transformed array
* @throws MathIllegalArgumentException if the length of the data array is
* not a power of two, or the first element of the data array is not zero
*/
protected double[] fst(double[] f) throws MathIllegalArgumentException {
final double[] transformed = new double[f.length];
if (!ArithmeticUtils.isPowerOfTwo(f.length)) {
throw new MathIllegalArgumentException(
LocalizedFormats.NOT_POWER_OF_TWO_CONSIDER_PADDING,
Integer.valueOf(f.length));
}
if (f[0] != 0.0) {
throw new MathIllegalArgumentException(
LocalizedFormats.FIRST_ELEMENT_NOT_ZERO,
Double.valueOf(f[0]));
}
final int n = f.length;
if (n == 1) { // trivial case
transformed[0] = 0.0;
return transformed;
}
// construct a new array and perform FFT on it
final double[] x = new double[n];
x[0] = 0.0;
x[n >> 1] = 2.0 * f[n >> 1];
for (int i = 1; i < (n >> 1); i++) {
final double a = FastMath.sin(i * FastMath.PI / n) * (f[i] + f[n - i]);
final double b = 0.5 * (f[i] - f[n - i]);
x[i] = a + b;
x[n - i] = a - b;
}
FastFourierTransformer transformer;
transformer = new FastFourierTransformer(DftNormalization.STANDARD);
Complex[] y = transformer.transform(x, TransformType.FORWARD);
// reconstruct the FST result for the original array
transformed[0] = 0.0;
transformed[1] = 0.5 * y[0].getReal();
for (int i = 1; i < (n >> 1); i++) {
transformed[2 * i] = -y[i].getImaginary();
transformed[2 * i + 1] = y[i].getReal() + transformed[2 * i - 1];
}
return transformed;
}
Example 2
| Source File: FastSineTransformer.java From astor with GNU General Public License v2.0 | 4 votes |
|
/**
* Perform the FST algorithm (including inverse). The first element of the
* data set is required to be {@code 0}.
*
* @param f the real data array to be transformed
* @return the real transformed array
* @throws MathIllegalArgumentException if the length of the data array is
* not a power of two, or the first element of the data array is not zero
*/
protected double[] fst(double[] f) throws MathIllegalArgumentException {
final double[] transformed = new double[f.length];
if (!ArithmeticUtils.isPowerOfTwo(f.length)) {
throw new MathIllegalArgumentException(
LocalizedFormats.NOT_POWER_OF_TWO_CONSIDER_PADDING,
Integer.valueOf(f.length));
}
if (f[0] != 0.0) {
throw new MathIllegalArgumentException(
LocalizedFormats.FIRST_ELEMENT_NOT_ZERO,
Double.valueOf(f[0]));
}
final int n = f.length;
if (n == 1) { // trivial case
transformed[0] = 0.0;
return transformed;
}
// construct a new array and perform FFT on it
final double[] x = new double[n];
x[0] = 0.0;
x[n >> 1] = 2.0 * f[n >> 1];
for (int i = 1; i < (n >> 1); i++) {
final double a = FastMath.sin(i * FastMath.PI / n) * (f[i] + f[n - i]);
final double b = 0.5 * (f[i] - f[n - i]);
x[i] = a + b;
x[n - i] = a - b;
}
FastFourierTransformer transformer;
transformer = new FastFourierTransformer(DftNormalization.STANDARD);
Complex[] y = transformer.transform(x, TransformType.FORWARD);
// reconstruct the FST result for the original array
transformed[0] = 0.0;
transformed[1] = 0.5 * y[0].getReal();
for (int i = 1; i < (n >> 1); i++) {
transformed[2 * i] = -y[i].getImaginary();
transformed[2 * i + 1] = y[i].getReal() + transformed[2 * i - 1];
}
return transformed;
}
Example 3
| Source File: FastSineTransformer.java From astor with GNU General Public License v2.0 | 4 votes |
|
/**
* Perform the FST algorithm (including inverse). The first element of the
* data set is required to be {@code 0}.
*
* @param f the real data array to be transformed
* @return the real transformed array
* @throws MathIllegalArgumentException if the length of the data array is
* not a power of two, or the first element of the data array is not zero
*/
protected double[] fst(double[] f) throws MathIllegalArgumentException {
final double[] transformed = new double[f.length];
if (!ArithmeticUtils.isPowerOfTwo(f.length)) {
throw new MathIllegalArgumentException(
LocalizedFormats.NOT_POWER_OF_TWO_CONSIDER_PADDING,
Integer.valueOf(f.length));
}
if (f[0] != 0.0) {
throw new MathIllegalArgumentException(
LocalizedFormats.FIRST_ELEMENT_NOT_ZERO,
Double.valueOf(f[0]));
}
final int n = f.length;
if (n == 1) { // trivial case
transformed[0] = 0.0;
return transformed;
}
// construct a new array and perform FFT on it
final double[] x = new double[n];
x[0] = 0.0;
x[n >> 1] = 2.0 * f[n >> 1];
for (int i = 1; i < (n >> 1); i++) {
final double a = FastMath.sin(i * FastMath.PI / n) * (f[i] + f[n - i]);
final double b = 0.5 * (f[i] - f[n - i]);
x[i] = a + b;
x[n - i] = a - b;
}
FastFourierTransformer transformer;
transformer = new FastFourierTransformer(DftNormalization.STANDARD);
Complex[] y = transformer.transform(x, TransformType.FORWARD);
// reconstruct the FST result for the original array
transformed[0] = 0.0;
transformed[1] = 0.5 * y[0].getReal();
for (int i = 1; i < (n >> 1); i++) {
transformed[2 * i] = -y[i].getImaginary();
transformed[2 * i + 1] = y[i].getReal() + transformed[2 * i - 1];
}
return transformed;
}
Example 4
| Source File: FastSineTransformer.java From astor with GNU General Public License v2.0 | 4 votes |
|
/**
* Perform the FST algorithm (including inverse). The first element of the
* data set is required to be {@code 0}.
*
* @param f the real data array to be transformed
* @return the real transformed array
* @throws MathIllegalArgumentException if the length of the data array is
* not a power of two, or the first element of the data array is not zero
*/
protected double[] fst(double[] f) throws MathIllegalArgumentException {
final double[] transformed = new double[f.length];
if (!ArithmeticUtils.isPowerOfTwo(f.length)) {
throw new MathIllegalArgumentException(
LocalizedFormats.NOT_POWER_OF_TWO_CONSIDER_PADDING,
Integer.valueOf(f.length));
}
if (f[0] != 0.0) {
throw new MathIllegalArgumentException(
LocalizedFormats.FIRST_ELEMENT_NOT_ZERO,
Double.valueOf(f[0]));
}
final int n = f.length;
if (n == 1) { // trivial case
transformed[0] = 0.0;
return transformed;
}
// construct a new array and perform FFT on it
final double[] x = new double[n];
x[0] = 0.0;
x[n >> 1] = 2.0 * f[n >> 1];
for (int i = 1; i < (n >> 1); i++) {
final double a = FastMath.sin(i * FastMath.PI / n) * (f[i] + f[n - i]);
final double b = 0.5 * (f[i] - f[n - i]);
x[i] = a + b;
x[n - i] = a - b;
}
FastFourierTransformer transformer;
transformer = new FastFourierTransformer(DftNormalization.STANDARD);
Complex[] y = transformer.transform(x, TransformType.FORWARD);
// reconstruct the FST result for the original array
transformed[0] = 0.0;
transformed[1] = 0.5 * y[0].getReal();
for (int i = 1; i < (n >> 1); i++) {
transformed[2 * i] = -y[i].getImaginary();
transformed[2 * i + 1] = y[i].getReal() + transformed[2 * i - 1];
}
return transformed;
}
Example 5
| Source File: FastSineTransformer.java From astor with GNU General Public License v2.0 | 4 votes |
|
/**
* Perform the FST algorithm (including inverse). The first element of the
* data set is required to be {@code 0}.
*
* @param f the real data array to be transformed
* @return the real transformed array
* @throws MathIllegalArgumentException if the length of the data array is
* not a power of two, or the first element of the data array is not zero
*/
protected double[] fst(double[] f) throws MathIllegalArgumentException {
final double[] transformed = new double[f.length];
if (!ArithmeticUtils.isPowerOfTwo(f.length)) {
throw new MathIllegalArgumentException(
LocalizedFormats.NOT_POWER_OF_TWO_CONSIDER_PADDING,
Integer.valueOf(f.length));
}
if (f[0] != 0.0) {
throw new MathIllegalArgumentException(
LocalizedFormats.FIRST_ELEMENT_NOT_ZERO,
Double.valueOf(f[0]));
}
final int n = f.length;
if (n == 1) { // trivial case
transformed[0] = 0.0;
return transformed;
}
// construct a new array and perform FFT on it
final double[] x = new double[n];
x[0] = 0.0;
x[n >> 1] = 2.0 * f[n >> 1];
for (int i = 1; i < (n >> 1); i++) {
final double a = FastMath.sin(i * FastMath.PI / n) * (f[i] + f[n - i]);
final double b = 0.5 * (f[i] - f[n - i]);
x[i] = a + b;
x[n - i] = a - b;
}
FastFourierTransformer transformer;
transformer = new FastFourierTransformer(DftNormalization.STANDARD);
Complex[] y = transformer.transform(x, TransformType.FORWARD);
// reconstruct the FST result for the original array
transformed[0] = 0.0;
transformed[1] = 0.5 * y[0].getReal();
for (int i = 1; i < (n >> 1); i++) {
transformed[2 * i] = -y[i].getImaginary();
transformed[2 * i + 1] = y[i].getReal() + transformed[2 * i - 1];
}
return transformed;
}
Example 6
| Source File: FastSineTransformer.java From astor with GNU General Public License v2.0 | 4 votes |
|
/**
* Perform the FST algorithm (including inverse). The first element of the
* data set is required to be {@code 0}.
*
* @param f the real data array to be transformed
* @return the real transformed array
* @throws MathIllegalArgumentException if the length of the data array is
* not a power of two, or the first element of the data array is not zero
*/
protected double[] fst(double[] f) throws MathIllegalArgumentException {
final double[] transformed = new double[f.length];
if (!ArithmeticUtils.isPowerOfTwo(f.length)) {
throw new MathIllegalArgumentException(
LocalizedFormats.NOT_POWER_OF_TWO_CONSIDER_PADDING,
Integer.valueOf(f.length));
}
if (f[0] != 0.0) {
throw new MathIllegalArgumentException(
LocalizedFormats.FIRST_ELEMENT_NOT_ZERO,
Double.valueOf(f[0]));
}
final int n = f.length;
if (n == 1) { // trivial case
transformed[0] = 0.0;
return transformed;
}
// construct a new array and perform FFT on it
final double[] x = new double[n];
x[0] = 0.0;
x[n >> 1] = 2.0 * f[n >> 1];
for (int i = 1; i < (n >> 1); i++) {
final double a = FastMath.sin(i * FastMath.PI / n) * (f[i] + f[n - i]);
final double b = 0.5 * (f[i] - f[n - i]);
x[i] = a + b;
x[n - i] = a - b;
}
FastFourierTransformer transformer;
transformer = new FastFourierTransformer(DftNormalization.STANDARD);
Complex[] y = transformer.transform(x, TransformType.FORWARD);
// reconstruct the FST result for the original array
transformed[0] = 0.0;
transformed[1] = 0.5 * y[0].getReal();
for (int i = 1; i < (n >> 1); i++) {
transformed[2 * i] = -y[i].getImaginary();
transformed[2 * i + 1] = y[i].getReal() + transformed[2 * i - 1];
}
return transformed;
}
Example 7
| Source File: FastSineTransformer.java From astor with GNU General Public License v2.0 | 4 votes |
|
/**
* Perform the FST algorithm (including inverse). The first element of the
* data set is required to be {@code 0}.
*
* @param f the real data array to be transformed
* @return the real transformed array
* @throws MathIllegalArgumentException if the length of the data array is
* not a power of two, or the first element of the data array is not zero
*/
protected double[] fst(double[] f) throws MathIllegalArgumentException {
final double[] transformed = new double[f.length];
if (!ArithmeticUtils.isPowerOfTwo(f.length)) {
throw new MathIllegalArgumentException(
LocalizedFormats.NOT_POWER_OF_TWO_CONSIDER_PADDING,
Integer.valueOf(f.length));
}
if (f[0] != 0.0) {
throw new MathIllegalArgumentException(
LocalizedFormats.FIRST_ELEMENT_NOT_ZERO,
Double.valueOf(f[0]));
}
final int n = f.length;
if (n == 1) { // trivial case
transformed[0] = 0.0;
return transformed;
}
// construct a new array and perform FFT on it
final double[] x = new double[n];
x[0] = 0.0;
x[n >> 1] = 2.0 * f[n >> 1];
for (int i = 1; i < (n >> 1); i++) {
final double a = FastMath.sin(i * FastMath.PI / n) * (f[i] + f[n - i]);
final double b = 0.5 * (f[i] - f[n - i]);
x[i] = a + b;
x[n - i] = a - b;
}
FastFourierTransformer transformer;
transformer = new FastFourierTransformer(DftNormalization.STANDARD);
Complex[] y = transformer.transform(x, TransformType.FORWARD);
// reconstruct the FST result for the original array
transformed[0] = 0.0;
transformed[1] = 0.5 * y[0].getReal();
for (int i = 1; i < (n >> 1); i++) {
transformed[2 * i] = -y[i].getImaginary();
transformed[2 * i + 1] = y[i].getReal() + transformed[2 * i - 1];
}
return transformed;
}
Example 8
| Source File: FastSineTransformer.java From astor with GNU General Public License v2.0 | 4 votes |
|
/**
* Perform the FST algorithm (including inverse). The first element of the
* data set is required to be {@code 0}.
*
* @param f the real data array to be transformed
* @return the real transformed array
* @throws MathIllegalArgumentException if the length of the data array is
* not a power of two, or the first element of the data array is not zero
*/
protected double[] fst(double[] f) throws MathIllegalArgumentException {
final double[] transformed = new double[f.length];
if (!ArithmeticUtils.isPowerOfTwo(f.length)) {
throw new MathIllegalArgumentException(
LocalizedFormats.NOT_POWER_OF_TWO_CONSIDER_PADDING,
Integer.valueOf(f.length));
}
if (f[0] != 0.0) {
throw new MathIllegalArgumentException(
LocalizedFormats.FIRST_ELEMENT_NOT_ZERO,
Double.valueOf(f[0]));
}
final int n = f.length;
if (n == 1) { // trivial case
transformed[0] = 0.0;
return transformed;
}
// construct a new array and perform FFT on it
final double[] x = new double[n];
x[0] = 0.0;
x[n >> 1] = 2.0 * f[n >> 1];
for (int i = 1; i < (n >> 1); i++) {
final double a = FastMath.sin(i * FastMath.PI / n) * (f[i] + f[n - i]);
final double b = 0.5 * (f[i] - f[n - i]);
x[i] = a + b;
x[n - i] = a - b;
}
FastFourierTransformer transformer;
transformer = new FastFourierTransformer(DftNormalization.STANDARD);
Complex[] y = transformer.transform(x, TransformType.FORWARD);
// reconstruct the FST result for the original array
transformed[0] = 0.0;
transformed[1] = 0.5 * y[0].getReal();
for (int i = 1; i < (n >> 1); i++) {
transformed[2 * i] = -y[i].getImaginary();
transformed[2 * i + 1] = y[i].getReal() + transformed[2 * i - 1];
}
return transformed;
}
