/**
* A test of {@link FloatFFT_2D#realInverse(float[][], boolean)}, with the second parameter set to
* <code>true</code>.
*/
@Test
public void testRealInverseScaled2dInput() {
if (!ConcurrencyUtils.isPowerOf2(numRows)) {
return;
}
if (!ConcurrencyUtils.isPowerOf2(numCols)) {
return;
}
final float[][] actual = new float[numRows][numCols];
final float[][] expected = new float[numRows][numCols];
for (int r = 0; r < numRows; r++) {
for (int c = 0; c < numCols; c++) {
final float rnd = random.nextFloat();
actual[r][c] = rnd;
expected[r][c] = rnd;
}
}
fft.realForward(actual);
fft.realInverse(actual, true);
double rmse = IOUtils.computeRMSE(actual, expected);
Assert.assertEquals(
String.format(DEFAULT_MESSAGE, numThreads, numRows, numCols) + ", rmse = " + rmse,
0.0,
rmse,
EPS);
}
/** A test of {@link FloatFFT_2D#realForwardFull(FloatLargeArray)}. */
@Test
public void testRealForwardFullLarge() {
final FloatLargeArray actual = new FloatLargeArray(2 * numRows * numCols, false);
final float[][] expected0 = new float[numRows][2 * numCols];
final FloatLargeArray expected = new FloatLargeArray(numRows * 2 * numCols, false);
for (int r = 0; r < numRows; r++) {
for (int c = 0; c < numCols; c++) {
final float rnd = random.nextFloat();
actual.setDouble(r * numCols + c, rnd);
expected0[r][2 * c] = rnd;
}
}
fft.realForwardFull(actual);
complexForward(expected0);
for (int r = 0; r < numRows; r++) {
for (int c = 0; c < 2 * numCols; c++) {
expected.setDouble(2 * r * numCols + c, expected0[r][c]);
}
}
double rmse = IOUtils.computeRMSE(actual, expected);
Assert.assertEquals(
String.format(DEFAULT_MESSAGE, numThreads, numRows, numCols) + ", rmse = " + rmse,
0.0,
rmse,
EPS);
}
/** A test of {@link FloatFFT_2D#realForward(FloatLargeArray)}. */
@Test
public void testRealForwardLarge() {
if (!ConcurrencyUtils.isPowerOf2(numRows)) {
return;
}
if (!ConcurrencyUtils.isPowerOf2(numCols)) {
return;
}
final FloatLargeArray actual = new FloatLargeArray(2 * numRows * numCols, false);
final FloatLargeArray expected = new FloatLargeArray(numRows * 2 * numCols, false);
for (int r = 0; r < numRows; r++) {
for (int c = 0; c < numCols; c++) {
final float rnd = random.nextFloat();
actual.setDouble(r * numCols + c, rnd);
expected.setDouble(r * 2 * numCols + 2 * c, rnd);
}
}
fft.realForward(actual);
fft.complexForward(expected);
fillSymmetric(actual, numRows, numCols);
double rmse = IOUtils.computeRMSE(actual, expected);
Assert.assertEquals(
String.format(DEFAULT_MESSAGE, numThreads, numRows, numCols) + ", rmse = " + rmse,
0.0,
rmse,
EPS);
}
/**
* A test of {@link FloatFFT_2D#complexInverse(float[][], boolean)}, with the second parameter set
* to <code>false</code>.
*/
@Test
public void testComplexInverseUnScaled2dInput() {
final float[][] expected = new float[numRows][2 * numCols];
final float[][] actual = new float[numRows][2 * numCols];
for (int r = 0; r < numRows; r++) {
for (int c = 0; c < 2 * numCols; c++) {
final float rnd = random.nextFloat();
expected[r][c] = rnd;
actual[r][c] = rnd;
}
}
fft.complexForward(actual);
fft.complexInverse(actual, false);
final float s = numRows * numCols;
for (int r = 0; r < numRows; r++) {
for (int c = 0; c < 2 * numCols; c++) {
actual[r][c] = actual[r][c] / s;
}
}
double rmse = IOUtils.computeRMSE(actual, expected);
Assert.assertEquals(
String.format(DEFAULT_MESSAGE, numThreads, numRows, numCols) + ", rmse = " + rmse,
0.0,
rmse,
EPS);
}
/** A test of {@link FloatFFT_2D#complexForward(float[])}. */
@Test
public void testComplexForward1dInput() {
final float[] actual = new float[2 * numRows * numCols];
final float[][] expected0 = new float[numRows][2 * numCols];
final float[] expected = new float[2 * numRows * numCols];
for (int r = 0; r < numRows; r++) {
for (int c = 0; c < 2 * numCols; c++) {
final float rnd = random.nextFloat();
actual[2 * r * numCols + c] = rnd;
expected0[r][c] = rnd;
}
}
fft.complexForward(actual);
complexForward(expected0);
for (int r = 0; r < numRows; r++) {
for (int c = 0; c < 2 * numCols; c++) {
expected[2 * r * numCols + c] = expected0[r][c];
}
}
double rmse = IOUtils.computeRMSE(actual, expected);
Assert.assertEquals(
String.format(DEFAULT_MESSAGE, numThreads, numRows, numCols) + ", rmse = " + rmse,
0.0,
rmse,
EPS);
}
/**
* A test of {@link FloatFFT_2D#complexInverse(FloatLargeArray, boolean)}, with the second
* parameter set to <code>true</code>.
*/
@Test
public void testComplexInverseScaledLarge() {
final FloatLargeArray expected = new FloatLargeArray(2 * numRows * numCols, false);
final FloatLargeArray actual = new FloatLargeArray(2 * numRows * numCols, false);
for (int i = 0; i < actual.length(); i++) {
final float rnd = random.nextFloat();
actual.setDouble(i, rnd);
expected.setDouble(i, rnd);
}
fft.complexForward(actual);
fft.complexInverse(actual, true);
double rmse = IOUtils.computeRMSE(actual, expected);
Assert.assertEquals(
String.format(DEFAULT_MESSAGE, numThreads, numRows, numCols) + ", rmse = " + rmse,
0.0,
rmse,
EPS);
}
/**
* A test of {@link FloatFFT_2D#complexInverse(float[], boolean)}, with the second parameter set
* to <code>true</code>.
*/
@Test
public void testComplexInverseScaled1dInput() {
final float[] expected = new float[2 * numRows * numCols];
final float[] actual = new float[2 * numRows * numCols];
for (int i = 0; i < actual.length; i++) {
final float rnd = random.nextFloat();
actual[i] = rnd;
expected[i] = rnd;
}
fft.complexForward(actual);
fft.complexInverse(actual, true);
double rmse = IOUtils.computeRMSE(actual, expected);
Assert.assertEquals(
String.format(DEFAULT_MESSAGE, numThreads, numRows, numCols) + ", rmse = " + rmse,
0.0,
rmse,
EPS);
}
/**
* A test of {@link FloatFFT_2D#realInverseFull(float[][], boolean)}, with the second parameter
* set to <code>true</code>.
*/
@Test
public void testRealInverseFullScaled2dInput() {
final float[][] actual = new float[numRows][2 * numCols];
final float[][] expected = new float[numRows][2 * numCols];
for (int r = 0; r < numRows; r++) {
for (int c = 0; c < numCols; c++) {
final float rnd = random.nextFloat();
actual[r][c] = rnd;
expected[r][2 * c] = rnd;
}
}
fft.realInverseFull(actual, true);
fft.complexInverse(expected, true);
double rmse = IOUtils.computeRMSE(actual, expected);
Assert.assertEquals(
String.format(DEFAULT_MESSAGE, numThreads, numRows, numCols) + ", rmse = " + rmse,
0.0,
rmse,
EPS);
}
/**
* A test of {@link FloatFFT_2D#realInverseFull(FloatLargeArray, boolean)}, with the second
* parameter set to <code>false</code>.
*/
@Test
public void testRealInverseFullUnscaledLarge() {
final FloatLargeArray actual = new FloatLargeArray(2 * numRows * numCols, false);
final FloatLargeArray expected = new FloatLargeArray(2 * numRows * numCols, false);
for (int r = 0; r < numRows; r++) {
for (int c = 0; c < numCols; c++) {
final float rnd = random.nextFloat();
final int index = r * numCols + c;
actual.set(index, rnd);
expected.setDouble(2 * index, rnd);
}
}
// TODO If the two following lines are permuted, this causes an array
// index out of bounds exception.
fft.complexInverse(expected, false);
fft.realInverseFull(actual, false);
double rmse = IOUtils.computeRMSE(actual, expected);
Assert.assertEquals(
String.format(DEFAULT_MESSAGE, numThreads, numRows, numCols) + ", rmse = " + rmse,
0.0,
rmse,
EPS);
}
/**
* A test of {@link FloatFFT_2D#realInverseFull(float[], boolean)}, with the second parameter set
* to <code>true</code>.
*/
@Test
public void testRealInverseFullScaled1dInput() {
final float[] actual = new float[2 * numRows * numCols];
final float[] expected = new float[2 * numRows * numCols];
for (int r = 0; r < numRows; r++) {
for (int c = 0; c < numCols; c++) {
final float rnd = random.nextFloat();
final int index = r * numCols + c;
actual[index] = rnd;
expected[2 * index] = rnd;
}
}
// TODO If the two following lines are permuted, this causes an array
// index out of bounds exception.
fft.complexInverse(expected, true);
fft.realInverseFull(actual, true);
double rmse = IOUtils.computeRMSE(actual, expected);
Assert.assertEquals(
String.format(DEFAULT_MESSAGE, numThreads, numRows, numCols) + ", rmse = " + rmse,
0.0,
rmse,
EPS);
}
