code
stringlengths 11
173k
| docstring
stringlengths 2
593k
| func_name
stringlengths 2
189
| language
stringclasses 1
value | repo
stringclasses 844
values | path
stringlengths 11
294
| url
stringlengths 60
339
| license
stringclasses 4
values |
|---|---|---|---|---|---|---|---|
public void powerPhaseFFTBeatRootOnset(float[] data,float[] power, float[] phase) {
powerPhaseFFT(data, power, phase);
power[0] = (float) Math.sqrt(data[0] * data[0] + data[1] * data[1]);
} |
Beatroot expects a different first power element
@param data The FFT transformed data.
@param power The array where the magnitudes or powers are going to be stored. It is half the length of data (FFT size).
@param phase The array where the phases are going to be stored. It is half the length of data (FFT size).
| FFT::powerPhaseFFTBeatRootOnset | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FFT.java | Apache-2.0 |
public void multiply(float[] data, float[] other){
assert data.length == other.length;
if(data.length!=other.length){
throw new IllegalArgumentException("Both arrays with imaginary numbers shouldb e of equal length");
}
for (int i = 1; i < data.length-1; i+=2) {
int realIndex = i;
int imgIndex = i + 1;
float tempReal = data[realIndex] * other[realIndex] + -1 * data[imgIndex] * other[imgIndex];
float tempImg = data[realIndex] * other[imgIndex] + data[imgIndex] * other[realIndex];
data[realIndex] = tempReal;
data[imgIndex] = tempImg;
//fix by perfecthu
//data[realIndex] = data[realIndex] * other[realIndex] + -1 * data[imgIndex] * other[imgIndex];
//data[imgIndex] = data[realIndex] * other[imgIndex] + data[imgIndex] * other[realIndex];
}
} |
Multiplies to arrays containing imaginary numbers. The data in the first argument
is modified! The real part is stored at <code>2*i</code>, the imaginary part <code>2*i+i</code>
@param data The array with imaginary numbers that is modified.
@param other The array with imaginary numbers that is not modified.
Data and other need to be the same length.
| FFT::multiply | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FFT.java | Apache-2.0 |
protected WindowFunction() {
} |
Construct a new window.
| WindowFunction::WindowFunction | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/WindowFunction.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/WindowFunction.java | Apache-2.0 |
public void apply(float[] samples) {
this.length = samples.length;
for (int n = 0; n < samples.length; n++) {
samples[n] *= value(samples.length, n);
}
} |
Apply the window function to a sample buffer.
@param samples
a sample buffer
| WindowFunction::apply | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/WindowFunction.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/WindowFunction.java | Apache-2.0 |
public float[] generateCurve(int length) {
float[] samples = new float[length];
for (int n = 0; n < length; n++) {
samples[n] = value(length, n);
}
return samples;
} |
Generates the curve of the window function.
@param length
the length of the window
@return the shape of the window function
| WindowFunction::generateCurve | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/WindowFunction.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/WindowFunction.java | Apache-2.0 |
public BlackmanWindow(float alpha) {
this.alpha = alpha;
} |
Constructs a Blackman window.
@param alpha The Blackman alpha parameter
| BlackmanWindow::BlackmanWindow | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/BlackmanWindow.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/BlackmanWindow.java | Apache-2.0 |
public BlackmanWindow() {
this(0.16f);
} |
Constructs a Blackman window.
@param alpha The Blackman alpha parameter
public BlackmanWindow(float alpha) {
this.alpha = alpha;
}
/** Constructs a Blackman window with a default alpha value of 0.16 | BlackmanWindow::BlackmanWindow | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/BlackmanWindow.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/BlackmanWindow.java | Apache-2.0 |
public CosineWindow() {
} |
A Cosine window function.
@author Damien Di Fede
@author Corban Brook
@see <a href="http://en.wikipedia.org/wiki/Window_function#Cosine_window">The
Cosine Window</a>
public class CosineWindow extends WindowFunction {
/** Constructs a Cosine window. | CosineWindow::CosineWindow | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/CosineWindow.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/CosineWindow.java | Apache-2.0 |
public BartlettWindow()
{
} |
A Bartlett window function.
@author Damien Di Fede
@author Corban Brook
@see <a href="http://en.wikipedia.org/wiki/Window_function#Bartlett_window_.28zero_valued_end-points.29">The Bartlett Window</a>
public class BartlettWindow extends WindowFunction
{
/** Constructs a Bartlett window. | BartlettWindow::BartlettWindow | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/BartlettWindow.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/BartlettWindow.java | Apache-2.0 |
public RectangularWindow() {
} |
A Rectangular window function A Rectangular window is equivalent to using no
window at all.
@author Damien Di Fede
@author Corban Brook
@see <a
href="http://en.wikipedia.org/wiki/Window_function#Rectangular_window">The
Rectangular Window</a>
public class RectangularWindow extends WindowFunction {
/** Constructs a Rectangular window. | RectangularWindow::RectangularWindow | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/RectangularWindow.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/RectangularWindow.java | Apache-2.0 |
public HannWindow() {
} |
A Hann window function.
@author Damien Di Fede
@author Corban Brook
@see <a href="http://en.wikipedia.org/wiki/Window_function#Hann_window">The
Hann Window</a>
public class HannWindow extends WindowFunction {
/** Constructs a Hann window. | HannWindow::HannWindow | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/HannWindow.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/HannWindow.java | Apache-2.0 |
public FloatFFT(int n) {
if (n < 1) {
throw new IllegalArgumentException("n must be greater than 0");
}
this.n = n;
if (!ConcurrencyUtils.isPowerOf2(n)) {
if (getReminder(n, factors) >= 211) {
plan = Plans.BLUESTEIN;
nBluestein = ConcurrencyUtils.nextPow2(n * 2 - 1);
bk1 = new float[2 * nBluestein];
bk2 = new float[2 * nBluestein];
this.ip = new int[2 + (int) Math.ceil(2 + (1 << (int) (Math.log(nBluestein + 0.5) / Math.log(2)) / 2))];
this.w = new float[nBluestein];
int twon = 2 * nBluestein;
nw = ip[0];
if (twon > (nw << 2)) {
nw = twon >> 2;
makewt(nw);
}
nc = ip[1];
if (nBluestein > (nc << 2)) {
nc = nBluestein >> 2;
makect(nc, w, nw);
}
bluesteini();
} else {
plan = Plans.MIXED_RADIX;
wtable = new float[4 * n + 15];
wtable_r = new float[2 * n + 15];
cffti();
rffti();
}
} else {
plan = Plans.SPLIT_RADIX;
this.ip = new int[2 + (int) Math.ceil(2 + (1 << (int) (Math.log(n + 0.5) / Math.log(2)) / 2))];
this.w = new float[n];
int twon = 2 * n;
nw = ip[0];
if (twon > (nw << 2)) {
nw = twon >> 2;
makewt(nw);
}
nc = ip[1];
if (n > (nc << 2)) {
nc = n >> 2;
makect(nc, w, nw);
}
}
} |
Creates new instance of FloatFFT.
@param n
size of data
| FloatFFT::FloatFFT | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
public void complexForward(float[] a) {
complexForward(a, 0);
} |
Computes 1D forward DFT of complex data leaving the result in
<code>a</code>. Complex number is stored as two float values in
sequence: the real and imaginary part, i.e. the size of the input array
must be greater or equal 2*n. The physical layout of the input data has
to be as follows:<br>
<pre>
a[2*k] = Re[k],
a[2*k+1] = Im[k], 0<=k<n
</pre>
@param a
data to transform
| FloatFFT::complexForward | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
public void complexForward(float[] a, int offa) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
cftbsub(2 * n, a, offa, ip, nw, w);
break;
case MIXED_RADIX:
cfftf(a, offa, -1);
break;
case BLUESTEIN:
bluestein_complex(a, offa, -1);
break;
}
} |
Computes 1D forward DFT of complex data leaving the result in
<code>a</code>. Complex number is stored as two float values in
sequence: the real and imaginary part, i.e. the size of the input array
must be greater or equal 2*n. The physical layout of the input data has
to be as follows:<br>
<pre>
a[offa+2*k] = Re[k],
a[offa+2*k+1] = Im[k], 0<=k<n
</pre>
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
| FloatFFT::complexForward | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
public void complexInverse(float[] a, boolean scale) {
complexInverse(a, 0, scale);
} |
Computes 1D inverse DFT of complex data leaving the result in
<code>a</code>. Complex number is stored as two float values in
sequence: the real and imaginary part, i.e. the size of the input array
must be greater or equal 2*n. The physical layout of the input data has
to be as follows:<br>
<pre>
a[2*k] = Re[k],
a[2*k+1] = Im[k], 0<=k<n
</pre>
@param a
data to transform
@param scale
if true then scaling is performed
| FloatFFT::complexInverse | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
public void complexInverse(float[] a, int offa, boolean scale) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
cftfsub(2 * n, a, offa, ip, nw, w);
break;
case MIXED_RADIX:
cfftf(a, offa, +1);
break;
case BLUESTEIN:
bluestein_complex(a, offa, 1);
break;
}
if (scale) {
scale(n, a, offa, true);
}
} |
Computes 1D inverse DFT of complex data leaving the result in
<code>a</code>. Complex number is stored as two float values in
sequence: the real and imaginary part, i.e. the size of the input array
must be greater or equal 2*n. The physical layout of the input data has
to be as follows:<br>
<pre>
a[offa+2*k] = Re[k],
a[offa+2*k+1] = Im[k], 0<=k<n
</pre>
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
| FloatFFT::complexInverse | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
public void realForward(float[] a) {
realForward(a, 0);
} |
Computes 1D forward DFT of real data leaving the result in <code>a</code>
. The physical layout of the output data is as follows:<br>
if n is even then
<pre>
a[2*k] = Re[k], 0<=k<n/2
a[2*k+1] = Im[k], 0<k<n/2
a[1] = Re[n/2]
</pre>
if n is odd then
<pre>
a[2*k] = Re[k], 0<=k<(n+1)/2
a[2*k+1] = Im[k], 0<k<(n-1)/2
a[1] = Im[(n-1)/2]
</pre>
This method computes only half of the elements of the real transform. The
other half satisfies the symmetry condition. If you want the full real
forward transform, use <code>realForwardFull</code>. To get back the
original data, use <code>realInverse</code> on the output of this method.
@param a
data to transform
| FloatFFT::realForward | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
public void realForward(float[] a, int offa) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
float xi;
if (n > 4) {
cftfsub(n, a, offa, ip, nw, w);
rftfsub(n, a, offa, nc, w, nw);
} else if (n == 4) {
cftx020(a, offa);
}
xi = a[offa] - a[offa + 1];
a[offa] += a[offa + 1];
a[offa + 1] = xi;
break;
case MIXED_RADIX:
rfftf(a, offa);
for (int k = n - 1; k >= 2; k--) {
int idx = offa + k;
float tmp = a[idx];
a[idx] = a[idx - 1];
a[idx - 1] = tmp;
}
break;
case BLUESTEIN:
bluestein_real_forward(a, offa);
break;
}
} |
Computes 1D forward DFT of real data leaving the result in <code>a</code>
. The physical layout of the output data is as follows:<br>
if n is even then
<pre>
a[offa+2*k] = Re[k], 0<=k<n/2
a[offa+2*k+1] = Im[k], 0<k<n/2
a[offa+1] = Re[n/2]
</pre>
if n is odd then
<pre>
a[offa+2*k] = Re[k], 0<=k<(n+1)/2
a[offa+2*k+1] = Im[k], 0<k<(n-1)/2
a[offa+1] = Im[(n-1)/2]
</pre>
This method computes only half of the elements of the real transform. The
other half satisfies the symmetry condition. If you want the full real
forward transform, use <code>realForwardFull</code>. To get back the
original data, use <code>realInverse</code> on the output of this method.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
| FloatFFT::realForward | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
public void realForwardFull(float[] a) {
realForwardFull(a, 0);
} |
Computes 1D forward DFT of real data leaving the result in <code>a</code>
. This method computes the full real forward transform, i.e. you will get
the same result as from <code>complexForward</code> called with all
imaginary parts equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data. To get back the original data,
use <code>complexInverse</code> on the output of this method.
@param a
data to transform
| FloatFFT::realForwardFull | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
public void realForwardFull(final float[] a, final int offa) {
final int twon = 2 * n;
switch (plan) {
case SPLIT_RADIX:
realForward(a, offa);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n / 2 > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
Future<?>[] futures = new Future[nthreads];
int k = n / 2 / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n / 2 : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
int idx1, idx2;
for (int k = firstIdx; k < lastIdx; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
int idx1, idx2;
for (int k = 0; k < n / 2; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
a[offa + n] = -a[offa + 1];
a[offa + 1] = 0;
break;
case MIXED_RADIX:
rfftf(a, offa);
int m;
if (n % 2 == 0) {
m = n / 2;
} else {
m = (n + 1) / 2;
}
for (int k = 1; k < m; k++) {
int idx1 = offa + twon - 2 * k;
int idx2 = offa + 2 * k;
a[idx1 + 1] = -a[idx2];
a[idx1] = a[idx2 - 1];
}
for (int k = 1; k < n; k++) {
int idx = offa + n - k;
float tmp = a[idx + 1];
a[idx + 1] = a[idx];
a[idx] = tmp;
}
a[offa + 1] = 0;
break;
case BLUESTEIN:
bluestein_real_full(a, offa, -1);
break;
}
} |
Computes 1D forward DFT of real data leaving the result in <code>a</code>
. This method computes the full real forward transform, i.e. you will get
the same result as from <code>complexForward</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data. To get back the original data,
use <code>complexInverse</code> on the output of this method.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
| FloatFFT::realForwardFull | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
public void realInverse(float[] a, boolean scale) {
realInverse(a, 0, scale);
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. The physical layout of the input data has to be as follows:<br>
if n is even then
<pre>
a[2*k] = Re[k], 0<=k<n/2
a[2*k+1] = Im[k], 0<k<n/2
a[1] = Re[n/2]
</pre>
if n is odd then
<pre>
a[2*k] = Re[k], 0<=k<(n+1)/2
a[2*k+1] = Im[k], 0<k<(n-1)/2
a[1] = Im[(n-1)/2]
</pre>
This method computes only half of the elements of the real transform. The
other half satisfies the symmetry condition. If you want the full real
inverse transform, use <code>realInverseFull</code>.
@param a
data to transform
@param scale
if true then scaling is performed
| FloatFFT::realInverse | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
public void realInverse(float[] a, int offa, boolean scale) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
a[offa + 1] = (float)(0.5 * (a[offa] - a[offa + 1]));
a[offa] -= a[offa + 1];
if (n > 4) {
rftfsub(n, a, offa, nc, w, nw);
cftbsub(n, a, offa, ip, nw, w);
} else if (n == 4) {
cftxc020(a, offa);
}
if (scale) {
scale(n / 2, a, offa, false);
}
break;
case MIXED_RADIX:
for (int k = 2; k < n; k++) {
int idx = offa + k;
float tmp = a[idx - 1];
a[idx - 1] = a[idx];
a[idx] = tmp;
}
rfftb(a, offa);
if (scale) {
scale(n, a, offa, false);
}
break;
case BLUESTEIN:
bluestein_real_inverse(a, offa);
if (scale) {
scale(n, a, offa, false);
}
break;
}
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. The physical layout of the input data has to be as follows:<br>
if n is even then
<pre>
a[offa+2*k] = Re[k], 0<=k<n/2
a[offa+2*k+1] = Im[k], 0<k<n/2
a[offa+1] = Re[n/2]
</pre>
if n is odd then
<pre>
a[offa+2*k] = Re[k], 0<=k<(n+1)/2
a[offa+2*k+1] = Im[k], 0<k<(n-1)/2
a[offa+1] = Im[(n-1)/2]
</pre>
This method computes only half of the elements of the real transform. The
other half satisfies the symmetry condition. If you want the full real
inverse transform, use <code>realInverseFull</code>.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
| FloatFFT::realInverse | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
public void realInverseFull(float[] a, boolean scale) {
realInverseFull(a, 0, scale);
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. This method computes the full real inverse transform, i.e. you will get
the same result as from <code>complexInverse</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data.
@param a
data to transform
@param scale
if true then scaling is performed
| FloatFFT::realInverseFull | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
public void realInverseFull(final float[] a, final int offa, boolean scale) {
final int twon = 2 * n;
switch (plan) {
case SPLIT_RADIX:
realInverse2(a, offa, scale);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n / 2 > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
Future<?>[] futures = new Future[nthreads];
int k = n / 2 / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n / 2 : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
int idx1, idx2;
for (int k = firstIdx; k < lastIdx; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
int idx1, idx2;
for (int k = 0; k < n / 2; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
a[offa + n] = -a[offa + 1];
a[offa + 1] = 0;
break;
case MIXED_RADIX:
rfftf(a, offa);
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
} else {
m = (n + 1) / 2;
}
for (int k = 1; k < m; k++) {
int idx1 = offa + 2 * k;
int idx2 = offa + twon - 2 * k;
a[idx1] = -a[idx1];
a[idx2 + 1] = -a[idx1];
a[idx2] = a[idx1 - 1];
}
for (int k = 1; k < n; k++) {
int idx = offa + n - k;
float tmp = a[idx + 1];
a[idx + 1] = a[idx];
a[idx] = tmp;
}
a[offa + 1] = 0;
break;
case BLUESTEIN:
bluestein_real_full(a, offa, 1);
if (scale) {
scale(n, a, offa, true);
}
break;
}
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. This method computes the full real inverse transform, i.e. you will get
the same result as from <code>complexInverse</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
| FloatFFT::realInverseFull | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
void rfftf(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, kh, nf, ip, iw, ido, idl1;
final float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 1;
l2 = n;
iw = twon - 1;
for (int k1 = 1; k1 <= nf; ++k1) {
kh = nf - k1;
ip = (int) wtable_r[kh + 2 + twon];
l1 = l2 / ip;
ido = n / l2;
idl1 = ido * l1;
iw -= (ip - 1) * ido;
na = 1 - na;
switch (ip) {
case 2:
if (na == 0) {
radf2(ido, l1, a, offa, ch, 0, iw);
} else {
radf2(ido, l1, ch, 0, a, offa, iw);
}
break;
case 3:
if (na == 0) {
radf3(ido, l1, a, offa, ch, 0, iw);
} else {
radf3(ido, l1, ch, 0, a, offa, iw);
}
break;
case 4:
if (na == 0) {
radf4(ido, l1, a, offa, ch, 0, iw);
} else {
radf4(ido, l1, ch, 0, a, offa, iw);
}
break;
case 5:
if (na == 0) {
radf5(ido, l1, a, offa, ch, 0, iw);
} else {
radf5(ido, l1, ch, 0, a, offa, iw);
}
break;
default:
if (ido == 1)
na = 1 - na;
if (na == 0) {
radfg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
na = 1;
} else {
radfg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
na = 0;
}
break;
}
l2 = l1;
}
if (na == 1)
return;
System.arraycopy(ch, 0, a, offa, n);
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. This method computes the full real inverse transform, i.e. you will get
the same result as from <code>complexInverse</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
public void realInverseFull(final float[] a, final int offa, boolean scale) {
final int twon = 2 * n;
switch (plan) {
case SPLIT_RADIX:
realInverse2(a, offa, scale);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n / 2 > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
Future<?>[] futures = new Future[nthreads];
int k = n / 2 / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n / 2 : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
int idx1, idx2;
for (int k = firstIdx; k < lastIdx; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
int idx1, idx2;
for (int k = 0; k < n / 2; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
a[offa + n] = -a[offa + 1];
a[offa + 1] = 0;
break;
case MIXED_RADIX:
rfftf(a, offa);
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
} else {
m = (n + 1) / 2;
}
for (int k = 1; k < m; k++) {
int idx1 = offa + 2 * k;
int idx2 = offa + twon - 2 * k;
a[idx1] = -a[idx1];
a[idx2 + 1] = -a[idx1];
a[idx2] = a[idx1 - 1];
}
for (int k = 1; k < n; k++) {
int idx = offa + n - k;
float tmp = a[idx + 1];
a[idx + 1] = a[idx];
a[idx] = tmp;
}
a[offa + 1] = 0;
break;
case BLUESTEIN:
bluestein_real_full(a, offa, 1);
if (scale) {
scale(n, a, offa, true);
}
break;
}
}
private void realInverse2(float[] a, int offa, boolean scale) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
float xi;
if (n > 4) {
cftfsub(n, a, offa, ip, nw, w);
rftbsub(n, a, offa, nc, w, nw);
} else if (n == 4) {
cftbsub(n, a, offa, ip, nw, w);
}
xi = a[offa] - a[offa + 1];
a[offa] += a[offa + 1];
a[offa + 1] = xi;
if (scale) {
scale(n, a, offa, false);
}
break;
case MIXED_RADIX:
rfftf(a, offa);
for (int k = n - 1; k >= 2; k--) {
int idx = offa + k;
float tmp = a[idx];
a[idx] = a[idx - 1];
a[idx - 1] = tmp;
}
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
for (int i = 1; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
} else {
m = (n - 1) / 2;
for (int i = 0; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
}
break;
case BLUESTEIN:
bluestein_real_inverse2(a, offa);
if (scale) {
scale(n, a, offa, false);
}
break;
}
}
private static int getReminder(int n, int[] factors) {
int reminder = n;
if (n <= 0) {
throw new IllegalArgumentException("n must be positive integer");
}
for (int i = 0; i < factors.length && reminder != 1; i++) {
int factor = factors[i];
while ((reminder % factor) == 0) {
reminder /= factor;
}
}
return reminder;
}
/* -------- initializing routines --------
/*---------------------------------------------------------
cffti: initialization of Complex FFT
--------------------------------------------------------
void cffti(int n, int offw) {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[offw + nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[offw + idx + 1] = wtable[offw + idx];
}
wtable[offw + 2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[offw + fourn] = n;
wtable[offw + 1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[offw + k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[offw + i - 1 + twon] = 1;
wtable[offw + i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[offw + idx - 1] = (float)Math.cos(arg);
wtable[offw + idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[offw + idx1 - 1] = wtable[offw + idx2 - 1];
wtable[offw + idx1] = wtable[offw + idx2];
}
}
l1 = l2;
}
}
void cffti() {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[idx + 1] = wtable[idx];
}
wtable[2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[fourn] = n;
wtable[1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[i - 1 + twon] = 1;
wtable[i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[idx - 1] = (float)Math.cos(arg);
wtable[idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[idx1 - 1] = wtable[idx2 - 1];
wtable[idx1] = wtable[idx2];
}
}
l1 = l2;
}
}
void rffti() {
if (n == 1)
return;
final int twon = 2 * n;
float argh;
int ntry = 0, i, j;
float argld;
int k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, is, nq, nr;
float arg;
int ido, ipm;
int nfm1;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
++j;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
++nf;
wtable_r[nf + 1 + twon] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + twon;
wtable_r[idx + 1] = wtable_r[idx];
}
wtable_r[2 + twon] = 2;
}
} while (nl != 1);
break;
}
wtable_r[twon] = n;
wtable_r[1 + twon] = nf;
argh = TWO_PI / (float) (n);
is = 0;
nfm1 = nf - 1;
l1 = 1;
if (nfm1 == 0)
return;
for (k1 = 1; k1 <= nfm1; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
ipm = ip - 1;
for (j = 1; j <= ipm; ++j) {
ld += l1;
i = is;
argld = (float) ld * argh;
fi = 0;
for (ii = 3; ii <= ido; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + n;
wtable_r[idx - 2] = (float)Math.cos(arg);
wtable_r[idx - 1] = (float)Math.sin(arg);
}
is += ido;
}
l1 = l2;
}
}
private void bluesteini() {
int k = 0;
float arg;
float pi_n = PI / n;
bk1[0] = 1;
bk1[1] = 0;
for (int i = 1; i < n; i++) {
k += 2 * i - 1;
if (k >= 2 * n)
k -= 2 * n;
arg = pi_n * k;
bk1[2 * i] = (float)Math.cos(arg);
bk1[2 * i + 1] = (float)Math.sin(arg);
}
float scale = (float)(1.0 / nBluestein);
bk2[0] = bk1[0] * scale;
bk2[1] = bk1[1] * scale;
for (int i = 2; i < 2 * n; i += 2) {
bk2[i] = bk1[i] * scale;
bk2[i + 1] = bk1[i + 1] * scale;
bk2[2 * nBluestein - i] = bk2[i];
bk2[2 * nBluestein - i + 1] = bk2[i + 1];
}
cftbsub(2 * nBluestein, bk2, 0, ip, nw, w);
}
private void makewt(int nw) {
int j, nwh, nw0, nw1;
float delta, wn4r, wk1r, wk1i, wk3r, wk3i;
float delta2, deltaj, deltaj3;
ip[0] = nw;
ip[1] = 1;
if (nw > 2) {
nwh = nw >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nwh);
delta2 = delta * 2;
wn4r = (float)Math.cos(delta * nwh);
w[0] = 1;
w[1] = wn4r;
if (nwh == 4) {
w[2] = (float)Math.cos(delta2);
w[3] = (float)Math.sin(delta2);
} else if (nwh > 4) {
makeipt(nw);
w[2] = (float)(0.5 / Math.cos(delta2));
w[3] = (float)(0.5 / Math.cos(delta * 6));
for (j = 4; j < nwh; j += 4) {
deltaj = delta * j;
deltaj3 = 3 * deltaj;
w[j] = (float)Math.cos(deltaj);
w[j + 1] = (float)Math.sin(deltaj);
w[j + 2] = (float)Math.cos(deltaj3);
w[j + 3] = (float)-Math.sin(deltaj3);
}
}
nw0 = 0;
while (nwh > 2) {
nw1 = nw0 + nwh;
nwh >>= 1;
w[nw1] = 1;
w[nw1 + 1] = wn4r;
if (nwh == 4) {
wk1r = w[nw0 + 4];
wk1i = w[nw0 + 5];
w[nw1 + 2] = wk1r;
w[nw1 + 3] = wk1i;
} else if (nwh > 4) {
wk1r = w[nw0 + 4];
wk3r = w[nw0 + 6];
w[nw1 + 2] = (float)(0.5 / wk1r);
w[nw1 + 3] = (float)(0.5 / wk3r);
for (j = 4; j < nwh; j += 4) {
int idx1 = nw0 + 2 * j;
int idx2 = nw1 + j;
wk1r = w[idx1];
wk1i = w[idx1 + 1];
wk3r = w[idx1 + 2];
wk3i = w[idx1 + 3];
w[idx2] = wk1r;
w[idx2 + 1] = wk1i;
w[idx2 + 2] = wk3r;
w[idx2 + 3] = wk3i;
}
}
nw0 = nw1;
}
}
}
private void makeipt(int nw) {
int j, l, m, m2, p, q;
ip[2] = 0;
ip[3] = 16;
m = 2;
for (l = nw; l > 32; l >>= 2) {
m2 = m << 1;
q = m2 << 3;
for (j = m; j < m2; j++) {
p = ip[j] << 2;
ip[m + j] = p;
ip[m2 + j] = p + q;
}
m = m2;
}
}
private void makect(int nc, float[] c, int startc) {
int j, nch;
float delta, deltaj;
ip[1] = nc;
if (nc > 1) {
nch = nc >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nch);
c[startc] = (float)Math.cos(delta * nch);
c[startc + nch] = (float)(0.5 * c[startc]);
for (j = 1; j < nch; j++) {
deltaj = delta * j;
c[startc + j] = (float)(0.5 * Math.cos(deltaj));
c[startc + nc - j] = (float)(0.5 * Math.sin(deltaj));
}
}
}
private void bluestein_complex(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_full(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_forward(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] + bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = -bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] + bk1[n] * ak[n];
}
}
private void bluestein_real_inverse(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
if (n % 2 == 0) {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n] = a[offa + 1] * bk1[n];
ak[n + 1] = a[offa + 1] * bk1[n + 1];
for (int i = n / 2 + 1; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
} else {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n - 1] = a[offa + n - 1] * bk1[n - 1] - a[offa + 1] * bk1[n];
ak[n] = a[offa + n - 1] * bk1[n] + a[offa + 1] * bk1[n - 1];
ak[n + 1] = a[offa + n - 1] * bk1[n + 1] + a[offa + 1] * bk1[n + 2];
ak[n + 2] = a[offa + n - 1] * bk1[n + 2] - a[offa + 1] * bk1[n + 1];
for (int i = (n - 1) / 2 + 2; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
}
private void bluestein_real_inverse2(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] - bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] - bk1[n] * ak[n];
}
}
/*---------------------------------------------------------
rfftf1: further processing of Real forward FFT
-------------------------------------------------------- | FloatFFT::rfftf | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
void rfftb(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, nf, ip, iw, ido, idl1;
float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 0;
l1 = 1;
iw = n;
for (int k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
l2 = ip * l1;
ido = n / l2;
idl1 = ido * l1;
switch (ip) {
case 2:
if (na == 0) {
radb2(ido, l1, a, offa, ch, 0, iw);
} else {
radb2(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
radb3(ido, l1, a, offa, ch, 0, iw);
} else {
radb3(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 4:
if (na == 0) {
radb4(ido, l1, a, offa, ch, 0, iw);
} else {
radb4(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
radb5(ido, l1, a, offa, ch, 0, iw);
} else {
radb5(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
default:
if (na == 0) {
radbg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
} else {
radbg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
}
if (ido == 1)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * ido;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, n);
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. This method computes the full real inverse transform, i.e. you will get
the same result as from <code>complexInverse</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
public void realInverseFull(final float[] a, final int offa, boolean scale) {
final int twon = 2 * n;
switch (plan) {
case SPLIT_RADIX:
realInverse2(a, offa, scale);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n / 2 > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
Future<?>[] futures = new Future[nthreads];
int k = n / 2 / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n / 2 : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
int idx1, idx2;
for (int k = firstIdx; k < lastIdx; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
int idx1, idx2;
for (int k = 0; k < n / 2; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
a[offa + n] = -a[offa + 1];
a[offa + 1] = 0;
break;
case MIXED_RADIX:
rfftf(a, offa);
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
} else {
m = (n + 1) / 2;
}
for (int k = 1; k < m; k++) {
int idx1 = offa + 2 * k;
int idx2 = offa + twon - 2 * k;
a[idx1] = -a[idx1];
a[idx2 + 1] = -a[idx1];
a[idx2] = a[idx1 - 1];
}
for (int k = 1; k < n; k++) {
int idx = offa + n - k;
float tmp = a[idx + 1];
a[idx + 1] = a[idx];
a[idx] = tmp;
}
a[offa + 1] = 0;
break;
case BLUESTEIN:
bluestein_real_full(a, offa, 1);
if (scale) {
scale(n, a, offa, true);
}
break;
}
}
private void realInverse2(float[] a, int offa, boolean scale) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
float xi;
if (n > 4) {
cftfsub(n, a, offa, ip, nw, w);
rftbsub(n, a, offa, nc, w, nw);
} else if (n == 4) {
cftbsub(n, a, offa, ip, nw, w);
}
xi = a[offa] - a[offa + 1];
a[offa] += a[offa + 1];
a[offa + 1] = xi;
if (scale) {
scale(n, a, offa, false);
}
break;
case MIXED_RADIX:
rfftf(a, offa);
for (int k = n - 1; k >= 2; k--) {
int idx = offa + k;
float tmp = a[idx];
a[idx] = a[idx - 1];
a[idx - 1] = tmp;
}
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
for (int i = 1; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
} else {
m = (n - 1) / 2;
for (int i = 0; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
}
break;
case BLUESTEIN:
bluestein_real_inverse2(a, offa);
if (scale) {
scale(n, a, offa, false);
}
break;
}
}
private static int getReminder(int n, int[] factors) {
int reminder = n;
if (n <= 0) {
throw new IllegalArgumentException("n must be positive integer");
}
for (int i = 0; i < factors.length && reminder != 1; i++) {
int factor = factors[i];
while ((reminder % factor) == 0) {
reminder /= factor;
}
}
return reminder;
}
/* -------- initializing routines --------
/*---------------------------------------------------------
cffti: initialization of Complex FFT
--------------------------------------------------------
void cffti(int n, int offw) {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[offw + nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[offw + idx + 1] = wtable[offw + idx];
}
wtable[offw + 2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[offw + fourn] = n;
wtable[offw + 1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[offw + k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[offw + i - 1 + twon] = 1;
wtable[offw + i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[offw + idx - 1] = (float)Math.cos(arg);
wtable[offw + idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[offw + idx1 - 1] = wtable[offw + idx2 - 1];
wtable[offw + idx1] = wtable[offw + idx2];
}
}
l1 = l2;
}
}
void cffti() {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[idx + 1] = wtable[idx];
}
wtable[2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[fourn] = n;
wtable[1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[i - 1 + twon] = 1;
wtable[i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[idx - 1] = (float)Math.cos(arg);
wtable[idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[idx1 - 1] = wtable[idx2 - 1];
wtable[idx1] = wtable[idx2];
}
}
l1 = l2;
}
}
void rffti() {
if (n == 1)
return;
final int twon = 2 * n;
float argh;
int ntry = 0, i, j;
float argld;
int k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, is, nq, nr;
float arg;
int ido, ipm;
int nfm1;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
++j;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
++nf;
wtable_r[nf + 1 + twon] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + twon;
wtable_r[idx + 1] = wtable_r[idx];
}
wtable_r[2 + twon] = 2;
}
} while (nl != 1);
break;
}
wtable_r[twon] = n;
wtable_r[1 + twon] = nf;
argh = TWO_PI / (float) (n);
is = 0;
nfm1 = nf - 1;
l1 = 1;
if (nfm1 == 0)
return;
for (k1 = 1; k1 <= nfm1; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
ipm = ip - 1;
for (j = 1; j <= ipm; ++j) {
ld += l1;
i = is;
argld = (float) ld * argh;
fi = 0;
for (ii = 3; ii <= ido; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + n;
wtable_r[idx - 2] = (float)Math.cos(arg);
wtable_r[idx - 1] = (float)Math.sin(arg);
}
is += ido;
}
l1 = l2;
}
}
private void bluesteini() {
int k = 0;
float arg;
float pi_n = PI / n;
bk1[0] = 1;
bk1[1] = 0;
for (int i = 1; i < n; i++) {
k += 2 * i - 1;
if (k >= 2 * n)
k -= 2 * n;
arg = pi_n * k;
bk1[2 * i] = (float)Math.cos(arg);
bk1[2 * i + 1] = (float)Math.sin(arg);
}
float scale = (float)(1.0 / nBluestein);
bk2[0] = bk1[0] * scale;
bk2[1] = bk1[1] * scale;
for (int i = 2; i < 2 * n; i += 2) {
bk2[i] = bk1[i] * scale;
bk2[i + 1] = bk1[i + 1] * scale;
bk2[2 * nBluestein - i] = bk2[i];
bk2[2 * nBluestein - i + 1] = bk2[i + 1];
}
cftbsub(2 * nBluestein, bk2, 0, ip, nw, w);
}
private void makewt(int nw) {
int j, nwh, nw0, nw1;
float delta, wn4r, wk1r, wk1i, wk3r, wk3i;
float delta2, deltaj, deltaj3;
ip[0] = nw;
ip[1] = 1;
if (nw > 2) {
nwh = nw >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nwh);
delta2 = delta * 2;
wn4r = (float)Math.cos(delta * nwh);
w[0] = 1;
w[1] = wn4r;
if (nwh == 4) {
w[2] = (float)Math.cos(delta2);
w[3] = (float)Math.sin(delta2);
} else if (nwh > 4) {
makeipt(nw);
w[2] = (float)(0.5 / Math.cos(delta2));
w[3] = (float)(0.5 / Math.cos(delta * 6));
for (j = 4; j < nwh; j += 4) {
deltaj = delta * j;
deltaj3 = 3 * deltaj;
w[j] = (float)Math.cos(deltaj);
w[j + 1] = (float)Math.sin(deltaj);
w[j + 2] = (float)Math.cos(deltaj3);
w[j + 3] = (float)-Math.sin(deltaj3);
}
}
nw0 = 0;
while (nwh > 2) {
nw1 = nw0 + nwh;
nwh >>= 1;
w[nw1] = 1;
w[nw1 + 1] = wn4r;
if (nwh == 4) {
wk1r = w[nw0 + 4];
wk1i = w[nw0 + 5];
w[nw1 + 2] = wk1r;
w[nw1 + 3] = wk1i;
} else if (nwh > 4) {
wk1r = w[nw0 + 4];
wk3r = w[nw0 + 6];
w[nw1 + 2] = (float)(0.5 / wk1r);
w[nw1 + 3] = (float)(0.5 / wk3r);
for (j = 4; j < nwh; j += 4) {
int idx1 = nw0 + 2 * j;
int idx2 = nw1 + j;
wk1r = w[idx1];
wk1i = w[idx1 + 1];
wk3r = w[idx1 + 2];
wk3i = w[idx1 + 3];
w[idx2] = wk1r;
w[idx2 + 1] = wk1i;
w[idx2 + 2] = wk3r;
w[idx2 + 3] = wk3i;
}
}
nw0 = nw1;
}
}
}
private void makeipt(int nw) {
int j, l, m, m2, p, q;
ip[2] = 0;
ip[3] = 16;
m = 2;
for (l = nw; l > 32; l >>= 2) {
m2 = m << 1;
q = m2 << 3;
for (j = m; j < m2; j++) {
p = ip[j] << 2;
ip[m + j] = p;
ip[m2 + j] = p + q;
}
m = m2;
}
}
private void makect(int nc, float[] c, int startc) {
int j, nch;
float delta, deltaj;
ip[1] = nc;
if (nc > 1) {
nch = nc >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nch);
c[startc] = (float)Math.cos(delta * nch);
c[startc + nch] = (float)(0.5 * c[startc]);
for (j = 1; j < nch; j++) {
deltaj = delta * j;
c[startc + j] = (float)(0.5 * Math.cos(deltaj));
c[startc + nc - j] = (float)(0.5 * Math.sin(deltaj));
}
}
}
private void bluestein_complex(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_full(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_forward(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] + bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = -bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] + bk1[n] * ak[n];
}
}
private void bluestein_real_inverse(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
if (n % 2 == 0) {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n] = a[offa + 1] * bk1[n];
ak[n + 1] = a[offa + 1] * bk1[n + 1];
for (int i = n / 2 + 1; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
} else {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n - 1] = a[offa + n - 1] * bk1[n - 1] - a[offa + 1] * bk1[n];
ak[n] = a[offa + n - 1] * bk1[n] + a[offa + 1] * bk1[n - 1];
ak[n + 1] = a[offa + n - 1] * bk1[n + 1] + a[offa + 1] * bk1[n + 2];
ak[n + 2] = a[offa + n - 1] * bk1[n + 2] - a[offa + 1] * bk1[n + 1];
for (int i = (n - 1) / 2 + 2; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
}
private void bluestein_real_inverse2(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] - bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] - bk1[n] * ak[n];
}
}
/*---------------------------------------------------------
rfftf1: further processing of Real forward FFT
--------------------------------------------------------
void rfftf(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, kh, nf, ip, iw, ido, idl1;
final float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 1;
l2 = n;
iw = twon - 1;
for (int k1 = 1; k1 <= nf; ++k1) {
kh = nf - k1;
ip = (int) wtable_r[kh + 2 + twon];
l1 = l2 / ip;
ido = n / l2;
idl1 = ido * l1;
iw -= (ip - 1) * ido;
na = 1 - na;
switch (ip) {
case 2:
if (na == 0) {
radf2(ido, l1, a, offa, ch, 0, iw);
} else {
radf2(ido, l1, ch, 0, a, offa, iw);
}
break;
case 3:
if (na == 0) {
radf3(ido, l1, a, offa, ch, 0, iw);
} else {
radf3(ido, l1, ch, 0, a, offa, iw);
}
break;
case 4:
if (na == 0) {
radf4(ido, l1, a, offa, ch, 0, iw);
} else {
radf4(ido, l1, ch, 0, a, offa, iw);
}
break;
case 5:
if (na == 0) {
radf5(ido, l1, a, offa, ch, 0, iw);
} else {
radf5(ido, l1, ch, 0, a, offa, iw);
}
break;
default:
if (ido == 1)
na = 1 - na;
if (na == 0) {
radfg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
na = 1;
} else {
radfg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
na = 0;
}
break;
}
l2 = l1;
}
if (na == 1)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*---------------------------------------------------------
rfftb1: further processing of Real backward FFT
-------------------------------------------------------- | FloatFFT::rfftb | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
void radf2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic, idx0, idx1, idx2, idx3, idx4;
float t1i, t1r, w1r, w1i;
int iw1;
iw1 = offset;
idx0 = l1 * ido;
idx1 = 2 * ido;
for (int k = 0; k < l1; k++) {
int oidx1 = out_off + k * idx1;
int oidx2 = oidx1 + idx1 - 1;
int iidx1 = in_off + k * ido;
int iidx2 = iidx1 + idx0;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx2] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
idx2 = 2 * idx1;
idx3 = idx2 + ido;
idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int oidx1 = out_off + i + idx2;
int oidx2 = out_off + ic + idx3;
int iidx1 = in_off + i + idx1;
int iidx2 = in_off + i + idx4;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
t1r = w1r * a2i + w1i * a2r;
t1i = w1r * a2r - w1i * a2i;
out[oidx1] = a1r + t1i;
out[oidx1 - 1] = a1i + t1r;
out[oidx2] = t1i - a1r;
out[oidx2 - 1] = a1i - t1r;
}
}
if (ido % 2 == 1)
return;
}
idx2 = 2 * idx1;
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
int oidx1 = out_off + idx2 + ido;
int iidx1 = in_off + ido - 1 + idx1;
out[oidx1] = -in[iidx1 + idx0];
out[oidx1 - 1] = in[iidx1];
}
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. This method computes the full real inverse transform, i.e. you will get
the same result as from <code>complexInverse</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
public void realInverseFull(final float[] a, final int offa, boolean scale) {
final int twon = 2 * n;
switch (plan) {
case SPLIT_RADIX:
realInverse2(a, offa, scale);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n / 2 > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
Future<?>[] futures = new Future[nthreads];
int k = n / 2 / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n / 2 : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
int idx1, idx2;
for (int k = firstIdx; k < lastIdx; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
int idx1, idx2;
for (int k = 0; k < n / 2; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
a[offa + n] = -a[offa + 1];
a[offa + 1] = 0;
break;
case MIXED_RADIX:
rfftf(a, offa);
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
} else {
m = (n + 1) / 2;
}
for (int k = 1; k < m; k++) {
int idx1 = offa + 2 * k;
int idx2 = offa + twon - 2 * k;
a[idx1] = -a[idx1];
a[idx2 + 1] = -a[idx1];
a[idx2] = a[idx1 - 1];
}
for (int k = 1; k < n; k++) {
int idx = offa + n - k;
float tmp = a[idx + 1];
a[idx + 1] = a[idx];
a[idx] = tmp;
}
a[offa + 1] = 0;
break;
case BLUESTEIN:
bluestein_real_full(a, offa, 1);
if (scale) {
scale(n, a, offa, true);
}
break;
}
}
private void realInverse2(float[] a, int offa, boolean scale) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
float xi;
if (n > 4) {
cftfsub(n, a, offa, ip, nw, w);
rftbsub(n, a, offa, nc, w, nw);
} else if (n == 4) {
cftbsub(n, a, offa, ip, nw, w);
}
xi = a[offa] - a[offa + 1];
a[offa] += a[offa + 1];
a[offa + 1] = xi;
if (scale) {
scale(n, a, offa, false);
}
break;
case MIXED_RADIX:
rfftf(a, offa);
for (int k = n - 1; k >= 2; k--) {
int idx = offa + k;
float tmp = a[idx];
a[idx] = a[idx - 1];
a[idx - 1] = tmp;
}
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
for (int i = 1; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
} else {
m = (n - 1) / 2;
for (int i = 0; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
}
break;
case BLUESTEIN:
bluestein_real_inverse2(a, offa);
if (scale) {
scale(n, a, offa, false);
}
break;
}
}
private static int getReminder(int n, int[] factors) {
int reminder = n;
if (n <= 0) {
throw new IllegalArgumentException("n must be positive integer");
}
for (int i = 0; i < factors.length && reminder != 1; i++) {
int factor = factors[i];
while ((reminder % factor) == 0) {
reminder /= factor;
}
}
return reminder;
}
/* -------- initializing routines --------
/*---------------------------------------------------------
cffti: initialization of Complex FFT
--------------------------------------------------------
void cffti(int n, int offw) {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[offw + nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[offw + idx + 1] = wtable[offw + idx];
}
wtable[offw + 2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[offw + fourn] = n;
wtable[offw + 1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[offw + k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[offw + i - 1 + twon] = 1;
wtable[offw + i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[offw + idx - 1] = (float)Math.cos(arg);
wtable[offw + idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[offw + idx1 - 1] = wtable[offw + idx2 - 1];
wtable[offw + idx1] = wtable[offw + idx2];
}
}
l1 = l2;
}
}
void cffti() {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[idx + 1] = wtable[idx];
}
wtable[2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[fourn] = n;
wtable[1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[i - 1 + twon] = 1;
wtable[i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[idx - 1] = (float)Math.cos(arg);
wtable[idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[idx1 - 1] = wtable[idx2 - 1];
wtable[idx1] = wtable[idx2];
}
}
l1 = l2;
}
}
void rffti() {
if (n == 1)
return;
final int twon = 2 * n;
float argh;
int ntry = 0, i, j;
float argld;
int k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, is, nq, nr;
float arg;
int ido, ipm;
int nfm1;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
++j;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
++nf;
wtable_r[nf + 1 + twon] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + twon;
wtable_r[idx + 1] = wtable_r[idx];
}
wtable_r[2 + twon] = 2;
}
} while (nl != 1);
break;
}
wtable_r[twon] = n;
wtable_r[1 + twon] = nf;
argh = TWO_PI / (float) (n);
is = 0;
nfm1 = nf - 1;
l1 = 1;
if (nfm1 == 0)
return;
for (k1 = 1; k1 <= nfm1; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
ipm = ip - 1;
for (j = 1; j <= ipm; ++j) {
ld += l1;
i = is;
argld = (float) ld * argh;
fi = 0;
for (ii = 3; ii <= ido; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + n;
wtable_r[idx - 2] = (float)Math.cos(arg);
wtable_r[idx - 1] = (float)Math.sin(arg);
}
is += ido;
}
l1 = l2;
}
}
private void bluesteini() {
int k = 0;
float arg;
float pi_n = PI / n;
bk1[0] = 1;
bk1[1] = 0;
for (int i = 1; i < n; i++) {
k += 2 * i - 1;
if (k >= 2 * n)
k -= 2 * n;
arg = pi_n * k;
bk1[2 * i] = (float)Math.cos(arg);
bk1[2 * i + 1] = (float)Math.sin(arg);
}
float scale = (float)(1.0 / nBluestein);
bk2[0] = bk1[0] * scale;
bk2[1] = bk1[1] * scale;
for (int i = 2; i < 2 * n; i += 2) {
bk2[i] = bk1[i] * scale;
bk2[i + 1] = bk1[i + 1] * scale;
bk2[2 * nBluestein - i] = bk2[i];
bk2[2 * nBluestein - i + 1] = bk2[i + 1];
}
cftbsub(2 * nBluestein, bk2, 0, ip, nw, w);
}
private void makewt(int nw) {
int j, nwh, nw0, nw1;
float delta, wn4r, wk1r, wk1i, wk3r, wk3i;
float delta2, deltaj, deltaj3;
ip[0] = nw;
ip[1] = 1;
if (nw > 2) {
nwh = nw >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nwh);
delta2 = delta * 2;
wn4r = (float)Math.cos(delta * nwh);
w[0] = 1;
w[1] = wn4r;
if (nwh == 4) {
w[2] = (float)Math.cos(delta2);
w[3] = (float)Math.sin(delta2);
} else if (nwh > 4) {
makeipt(nw);
w[2] = (float)(0.5 / Math.cos(delta2));
w[3] = (float)(0.5 / Math.cos(delta * 6));
for (j = 4; j < nwh; j += 4) {
deltaj = delta * j;
deltaj3 = 3 * deltaj;
w[j] = (float)Math.cos(deltaj);
w[j + 1] = (float)Math.sin(deltaj);
w[j + 2] = (float)Math.cos(deltaj3);
w[j + 3] = (float)-Math.sin(deltaj3);
}
}
nw0 = 0;
while (nwh > 2) {
nw1 = nw0 + nwh;
nwh >>= 1;
w[nw1] = 1;
w[nw1 + 1] = wn4r;
if (nwh == 4) {
wk1r = w[nw0 + 4];
wk1i = w[nw0 + 5];
w[nw1 + 2] = wk1r;
w[nw1 + 3] = wk1i;
} else if (nwh > 4) {
wk1r = w[nw0 + 4];
wk3r = w[nw0 + 6];
w[nw1 + 2] = (float)(0.5 / wk1r);
w[nw1 + 3] = (float)(0.5 / wk3r);
for (j = 4; j < nwh; j += 4) {
int idx1 = nw0 + 2 * j;
int idx2 = nw1 + j;
wk1r = w[idx1];
wk1i = w[idx1 + 1];
wk3r = w[idx1 + 2];
wk3i = w[idx1 + 3];
w[idx2] = wk1r;
w[idx2 + 1] = wk1i;
w[idx2 + 2] = wk3r;
w[idx2 + 3] = wk3i;
}
}
nw0 = nw1;
}
}
}
private void makeipt(int nw) {
int j, l, m, m2, p, q;
ip[2] = 0;
ip[3] = 16;
m = 2;
for (l = nw; l > 32; l >>= 2) {
m2 = m << 1;
q = m2 << 3;
for (j = m; j < m2; j++) {
p = ip[j] << 2;
ip[m + j] = p;
ip[m2 + j] = p + q;
}
m = m2;
}
}
private void makect(int nc, float[] c, int startc) {
int j, nch;
float delta, deltaj;
ip[1] = nc;
if (nc > 1) {
nch = nc >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nch);
c[startc] = (float)Math.cos(delta * nch);
c[startc + nch] = (float)(0.5 * c[startc]);
for (j = 1; j < nch; j++) {
deltaj = delta * j;
c[startc + j] = (float)(0.5 * Math.cos(deltaj));
c[startc + nc - j] = (float)(0.5 * Math.sin(deltaj));
}
}
}
private void bluestein_complex(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_full(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_forward(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] + bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = -bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] + bk1[n] * ak[n];
}
}
private void bluestein_real_inverse(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
if (n % 2 == 0) {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n] = a[offa + 1] * bk1[n];
ak[n + 1] = a[offa + 1] * bk1[n + 1];
for (int i = n / 2 + 1; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
} else {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n - 1] = a[offa + n - 1] * bk1[n - 1] - a[offa + 1] * bk1[n];
ak[n] = a[offa + n - 1] * bk1[n] + a[offa + 1] * bk1[n - 1];
ak[n + 1] = a[offa + n - 1] * bk1[n + 1] + a[offa + 1] * bk1[n + 2];
ak[n + 2] = a[offa + n - 1] * bk1[n + 2] - a[offa + 1] * bk1[n + 1];
for (int i = (n - 1) / 2 + 2; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
}
private void bluestein_real_inverse2(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] - bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] - bk1[n] * ak[n];
}
}
/*---------------------------------------------------------
rfftf1: further processing of Real forward FFT
--------------------------------------------------------
void rfftf(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, kh, nf, ip, iw, ido, idl1;
final float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 1;
l2 = n;
iw = twon - 1;
for (int k1 = 1; k1 <= nf; ++k1) {
kh = nf - k1;
ip = (int) wtable_r[kh + 2 + twon];
l1 = l2 / ip;
ido = n / l2;
idl1 = ido * l1;
iw -= (ip - 1) * ido;
na = 1 - na;
switch (ip) {
case 2:
if (na == 0) {
radf2(ido, l1, a, offa, ch, 0, iw);
} else {
radf2(ido, l1, ch, 0, a, offa, iw);
}
break;
case 3:
if (na == 0) {
radf3(ido, l1, a, offa, ch, 0, iw);
} else {
radf3(ido, l1, ch, 0, a, offa, iw);
}
break;
case 4:
if (na == 0) {
radf4(ido, l1, a, offa, ch, 0, iw);
} else {
radf4(ido, l1, ch, 0, a, offa, iw);
}
break;
case 5:
if (na == 0) {
radf5(ido, l1, a, offa, ch, 0, iw);
} else {
radf5(ido, l1, ch, 0, a, offa, iw);
}
break;
default:
if (ido == 1)
na = 1 - na;
if (na == 0) {
radfg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
na = 1;
} else {
radfg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
na = 0;
}
break;
}
l2 = l1;
}
if (na == 1)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*---------------------------------------------------------
rfftb1: further processing of Real backward FFT
--------------------------------------------------------
void rfftb(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, nf, ip, iw, ido, idl1;
float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 0;
l1 = 1;
iw = n;
for (int k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
l2 = ip * l1;
ido = n / l2;
idl1 = ido * l1;
switch (ip) {
case 2:
if (na == 0) {
radb2(ido, l1, a, offa, ch, 0, iw);
} else {
radb2(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
radb3(ido, l1, a, offa, ch, 0, iw);
} else {
radb3(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 4:
if (na == 0) {
radb4(ido, l1, a, offa, ch, 0, iw);
} else {
radb4(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
radb5(ido, l1, a, offa, ch, 0, iw);
} else {
radb5(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
default:
if (na == 0) {
radbg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
} else {
radbg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
}
if (ido == 1)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * ido;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*-------------------------------------------------
radf2: Real FFT's forward processing of factor 2
------------------------------------------------- | FloatFFT::radf2 | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
void radb2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic;
float t1i, t1r, w1r, w1i;
int iw1 = offset;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int oidx1 = out_off + idx1;
int iidx1 = in_off + idx2;
int iidx2 = in_off + ido - 1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx1 + idx0] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx5 = i - 1 + iw1;
int idx6 = out_off + i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
w1r = wtable_r[idx5 - 1];
w1i = wtable_r[idx5];
int iidx1 = idx7 + idx2;
int iidx2 = idx8 + idx3;
int oidx1 = idx6 + idx1;
int oidx2 = idx6 + idx4;
t1r = in[iidx1 - 1] - in[iidx2 - 1];
t1i = in[iidx1] + in[iidx2];
float i1i = in[iidx1];
float i1r = in[iidx1 - 1];
float i2i = in[iidx2];
float i2r = in[iidx2 - 1];
out[oidx1 - 1] = i1r + i2r;
out[oidx1] = i1i - i2i;
out[oidx2 - 1] = w1r * t1r - w1i * t1i;
out[oidx2] = w1r * t1i + w1i * t1r;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int oidx1 = out_off + ido - 1 + idx1;
int iidx1 = in_off + idx2 + ido;
out[oidx1] = 2 * in[iidx1 - 1];
out[oidx1 + idx0] = -2 * in[iidx1];
}
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. This method computes the full real inverse transform, i.e. you will get
the same result as from <code>complexInverse</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
public void realInverseFull(final float[] a, final int offa, boolean scale) {
final int twon = 2 * n;
switch (plan) {
case SPLIT_RADIX:
realInverse2(a, offa, scale);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n / 2 > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
Future<?>[] futures = new Future[nthreads];
int k = n / 2 / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n / 2 : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
int idx1, idx2;
for (int k = firstIdx; k < lastIdx; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
int idx1, idx2;
for (int k = 0; k < n / 2; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
a[offa + n] = -a[offa + 1];
a[offa + 1] = 0;
break;
case MIXED_RADIX:
rfftf(a, offa);
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
} else {
m = (n + 1) / 2;
}
for (int k = 1; k < m; k++) {
int idx1 = offa + 2 * k;
int idx2 = offa + twon - 2 * k;
a[idx1] = -a[idx1];
a[idx2 + 1] = -a[idx1];
a[idx2] = a[idx1 - 1];
}
for (int k = 1; k < n; k++) {
int idx = offa + n - k;
float tmp = a[idx + 1];
a[idx + 1] = a[idx];
a[idx] = tmp;
}
a[offa + 1] = 0;
break;
case BLUESTEIN:
bluestein_real_full(a, offa, 1);
if (scale) {
scale(n, a, offa, true);
}
break;
}
}
private void realInverse2(float[] a, int offa, boolean scale) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
float xi;
if (n > 4) {
cftfsub(n, a, offa, ip, nw, w);
rftbsub(n, a, offa, nc, w, nw);
} else if (n == 4) {
cftbsub(n, a, offa, ip, nw, w);
}
xi = a[offa] - a[offa + 1];
a[offa] += a[offa + 1];
a[offa + 1] = xi;
if (scale) {
scale(n, a, offa, false);
}
break;
case MIXED_RADIX:
rfftf(a, offa);
for (int k = n - 1; k >= 2; k--) {
int idx = offa + k;
float tmp = a[idx];
a[idx] = a[idx - 1];
a[idx - 1] = tmp;
}
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
for (int i = 1; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
} else {
m = (n - 1) / 2;
for (int i = 0; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
}
break;
case BLUESTEIN:
bluestein_real_inverse2(a, offa);
if (scale) {
scale(n, a, offa, false);
}
break;
}
}
private static int getReminder(int n, int[] factors) {
int reminder = n;
if (n <= 0) {
throw new IllegalArgumentException("n must be positive integer");
}
for (int i = 0; i < factors.length && reminder != 1; i++) {
int factor = factors[i];
while ((reminder % factor) == 0) {
reminder /= factor;
}
}
return reminder;
}
/* -------- initializing routines --------
/*---------------------------------------------------------
cffti: initialization of Complex FFT
--------------------------------------------------------
void cffti(int n, int offw) {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[offw + nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[offw + idx + 1] = wtable[offw + idx];
}
wtable[offw + 2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[offw + fourn] = n;
wtable[offw + 1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[offw + k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[offw + i - 1 + twon] = 1;
wtable[offw + i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[offw + idx - 1] = (float)Math.cos(arg);
wtable[offw + idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[offw + idx1 - 1] = wtable[offw + idx2 - 1];
wtable[offw + idx1] = wtable[offw + idx2];
}
}
l1 = l2;
}
}
void cffti() {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[idx + 1] = wtable[idx];
}
wtable[2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[fourn] = n;
wtable[1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[i - 1 + twon] = 1;
wtable[i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[idx - 1] = (float)Math.cos(arg);
wtable[idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[idx1 - 1] = wtable[idx2 - 1];
wtable[idx1] = wtable[idx2];
}
}
l1 = l2;
}
}
void rffti() {
if (n == 1)
return;
final int twon = 2 * n;
float argh;
int ntry = 0, i, j;
float argld;
int k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, is, nq, nr;
float arg;
int ido, ipm;
int nfm1;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
++j;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
++nf;
wtable_r[nf + 1 + twon] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + twon;
wtable_r[idx + 1] = wtable_r[idx];
}
wtable_r[2 + twon] = 2;
}
} while (nl != 1);
break;
}
wtable_r[twon] = n;
wtable_r[1 + twon] = nf;
argh = TWO_PI / (float) (n);
is = 0;
nfm1 = nf - 1;
l1 = 1;
if (nfm1 == 0)
return;
for (k1 = 1; k1 <= nfm1; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
ipm = ip - 1;
for (j = 1; j <= ipm; ++j) {
ld += l1;
i = is;
argld = (float) ld * argh;
fi = 0;
for (ii = 3; ii <= ido; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + n;
wtable_r[idx - 2] = (float)Math.cos(arg);
wtable_r[idx - 1] = (float)Math.sin(arg);
}
is += ido;
}
l1 = l2;
}
}
private void bluesteini() {
int k = 0;
float arg;
float pi_n = PI / n;
bk1[0] = 1;
bk1[1] = 0;
for (int i = 1; i < n; i++) {
k += 2 * i - 1;
if (k >= 2 * n)
k -= 2 * n;
arg = pi_n * k;
bk1[2 * i] = (float)Math.cos(arg);
bk1[2 * i + 1] = (float)Math.sin(arg);
}
float scale = (float)(1.0 / nBluestein);
bk2[0] = bk1[0] * scale;
bk2[1] = bk1[1] * scale;
for (int i = 2; i < 2 * n; i += 2) {
bk2[i] = bk1[i] * scale;
bk2[i + 1] = bk1[i + 1] * scale;
bk2[2 * nBluestein - i] = bk2[i];
bk2[2 * nBluestein - i + 1] = bk2[i + 1];
}
cftbsub(2 * nBluestein, bk2, 0, ip, nw, w);
}
private void makewt(int nw) {
int j, nwh, nw0, nw1;
float delta, wn4r, wk1r, wk1i, wk3r, wk3i;
float delta2, deltaj, deltaj3;
ip[0] = nw;
ip[1] = 1;
if (nw > 2) {
nwh = nw >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nwh);
delta2 = delta * 2;
wn4r = (float)Math.cos(delta * nwh);
w[0] = 1;
w[1] = wn4r;
if (nwh == 4) {
w[2] = (float)Math.cos(delta2);
w[3] = (float)Math.sin(delta2);
} else if (nwh > 4) {
makeipt(nw);
w[2] = (float)(0.5 / Math.cos(delta2));
w[3] = (float)(0.5 / Math.cos(delta * 6));
for (j = 4; j < nwh; j += 4) {
deltaj = delta * j;
deltaj3 = 3 * deltaj;
w[j] = (float)Math.cos(deltaj);
w[j + 1] = (float)Math.sin(deltaj);
w[j + 2] = (float)Math.cos(deltaj3);
w[j + 3] = (float)-Math.sin(deltaj3);
}
}
nw0 = 0;
while (nwh > 2) {
nw1 = nw0 + nwh;
nwh >>= 1;
w[nw1] = 1;
w[nw1 + 1] = wn4r;
if (nwh == 4) {
wk1r = w[nw0 + 4];
wk1i = w[nw0 + 5];
w[nw1 + 2] = wk1r;
w[nw1 + 3] = wk1i;
} else if (nwh > 4) {
wk1r = w[nw0 + 4];
wk3r = w[nw0 + 6];
w[nw1 + 2] = (float)(0.5 / wk1r);
w[nw1 + 3] = (float)(0.5 / wk3r);
for (j = 4; j < nwh; j += 4) {
int idx1 = nw0 + 2 * j;
int idx2 = nw1 + j;
wk1r = w[idx1];
wk1i = w[idx1 + 1];
wk3r = w[idx1 + 2];
wk3i = w[idx1 + 3];
w[idx2] = wk1r;
w[idx2 + 1] = wk1i;
w[idx2 + 2] = wk3r;
w[idx2 + 3] = wk3i;
}
}
nw0 = nw1;
}
}
}
private void makeipt(int nw) {
int j, l, m, m2, p, q;
ip[2] = 0;
ip[3] = 16;
m = 2;
for (l = nw; l > 32; l >>= 2) {
m2 = m << 1;
q = m2 << 3;
for (j = m; j < m2; j++) {
p = ip[j] << 2;
ip[m + j] = p;
ip[m2 + j] = p + q;
}
m = m2;
}
}
private void makect(int nc, float[] c, int startc) {
int j, nch;
float delta, deltaj;
ip[1] = nc;
if (nc > 1) {
nch = nc >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nch);
c[startc] = (float)Math.cos(delta * nch);
c[startc + nch] = (float)(0.5 * c[startc]);
for (j = 1; j < nch; j++) {
deltaj = delta * j;
c[startc + j] = (float)(0.5 * Math.cos(deltaj));
c[startc + nc - j] = (float)(0.5 * Math.sin(deltaj));
}
}
}
private void bluestein_complex(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_full(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_forward(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] + bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = -bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] + bk1[n] * ak[n];
}
}
private void bluestein_real_inverse(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
if (n % 2 == 0) {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n] = a[offa + 1] * bk1[n];
ak[n + 1] = a[offa + 1] * bk1[n + 1];
for (int i = n / 2 + 1; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
} else {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n - 1] = a[offa + n - 1] * bk1[n - 1] - a[offa + 1] * bk1[n];
ak[n] = a[offa + n - 1] * bk1[n] + a[offa + 1] * bk1[n - 1];
ak[n + 1] = a[offa + n - 1] * bk1[n + 1] + a[offa + 1] * bk1[n + 2];
ak[n + 2] = a[offa + n - 1] * bk1[n + 2] - a[offa + 1] * bk1[n + 1];
for (int i = (n - 1) / 2 + 2; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
}
private void bluestein_real_inverse2(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] - bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] - bk1[n] * ak[n];
}
}
/*---------------------------------------------------------
rfftf1: further processing of Real forward FFT
--------------------------------------------------------
void rfftf(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, kh, nf, ip, iw, ido, idl1;
final float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 1;
l2 = n;
iw = twon - 1;
for (int k1 = 1; k1 <= nf; ++k1) {
kh = nf - k1;
ip = (int) wtable_r[kh + 2 + twon];
l1 = l2 / ip;
ido = n / l2;
idl1 = ido * l1;
iw -= (ip - 1) * ido;
na = 1 - na;
switch (ip) {
case 2:
if (na == 0) {
radf2(ido, l1, a, offa, ch, 0, iw);
} else {
radf2(ido, l1, ch, 0, a, offa, iw);
}
break;
case 3:
if (na == 0) {
radf3(ido, l1, a, offa, ch, 0, iw);
} else {
radf3(ido, l1, ch, 0, a, offa, iw);
}
break;
case 4:
if (na == 0) {
radf4(ido, l1, a, offa, ch, 0, iw);
} else {
radf4(ido, l1, ch, 0, a, offa, iw);
}
break;
case 5:
if (na == 0) {
radf5(ido, l1, a, offa, ch, 0, iw);
} else {
radf5(ido, l1, ch, 0, a, offa, iw);
}
break;
default:
if (ido == 1)
na = 1 - na;
if (na == 0) {
radfg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
na = 1;
} else {
radfg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
na = 0;
}
break;
}
l2 = l1;
}
if (na == 1)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*---------------------------------------------------------
rfftb1: further processing of Real backward FFT
--------------------------------------------------------
void rfftb(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, nf, ip, iw, ido, idl1;
float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 0;
l1 = 1;
iw = n;
for (int k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
l2 = ip * l1;
ido = n / l2;
idl1 = ido * l1;
switch (ip) {
case 2:
if (na == 0) {
radb2(ido, l1, a, offa, ch, 0, iw);
} else {
radb2(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
radb3(ido, l1, a, offa, ch, 0, iw);
} else {
radb3(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 4:
if (na == 0) {
radb4(ido, l1, a, offa, ch, 0, iw);
} else {
radb4(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
radb5(ido, l1, a, offa, ch, 0, iw);
} else {
radb5(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
default:
if (na == 0) {
radbg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
} else {
radbg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
}
if (ido == 1)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * ido;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*-------------------------------------------------
radf2: Real FFT's forward processing of factor 2
-------------------------------------------------
void radf2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic, idx0, idx1, idx2, idx3, idx4;
float t1i, t1r, w1r, w1i;
int iw1;
iw1 = offset;
idx0 = l1 * ido;
idx1 = 2 * ido;
for (int k = 0; k < l1; k++) {
int oidx1 = out_off + k * idx1;
int oidx2 = oidx1 + idx1 - 1;
int iidx1 = in_off + k * ido;
int iidx2 = iidx1 + idx0;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx2] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
idx2 = 2 * idx1;
idx3 = idx2 + ido;
idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int oidx1 = out_off + i + idx2;
int oidx2 = out_off + ic + idx3;
int iidx1 = in_off + i + idx1;
int iidx2 = in_off + i + idx4;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
t1r = w1r * a2i + w1i * a2r;
t1i = w1r * a2r - w1i * a2i;
out[oidx1] = a1r + t1i;
out[oidx1 - 1] = a1i + t1r;
out[oidx2] = t1i - a1r;
out[oidx2 - 1] = a1i - t1r;
}
}
if (ido % 2 == 1)
return;
}
idx2 = 2 * idx1;
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
int oidx1 = out_off + idx2 + ido;
int iidx1 = in_off + ido - 1 + idx1;
out[oidx1] = -in[iidx1 + idx0];
out[oidx1 - 1] = in[iidx1];
}
}
/*-------------------------------------------------
radb2: Real FFT's backward processing of factor 2
------------------------------------------------- | FloatFFT::radb2 | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
void radf3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, di2, di3, cr2, dr2, dr3, ti2, ti3, tr2, tr3, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx3 = 2 * idx0;
int idx4 = (3 * k + 1) * ido;
int iidx1 = in_off + idx1;
int iidx2 = iidx1 + idx0;
int iidx3 = iidx1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
float i3r = in[iidx3];
cr2 = i2r + i3r;
out[out_off + 3 * idx1] = i1r + cr2;
out[out_off + idx4 + ido] = taui * (i3r - i2r);
out[out_off + ido - 1 + idx4] = i1r + taur * cr2;
}
if (ido == 1)
return;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int idx4 = 3 * idx3;
int idx5 = idx3 + idx0;
int idx6 = idx5 + idx0;
int idx7 = idx4 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx3;
int iidx2 = idx9 + idx5;
int iidx3 = idx9 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
cr2 = dr2 + dr3;
ci2 = di2 + di3;
tr2 = i1i + taur * cr2;
ti2 = i1r + taur * ci2;
tr3 = taui * (di2 - di3);
ti3 = taui * (dr3 - dr2);
int oidx1 = idx10 + idx4;
int oidx2 = idx11 + idx7;
int oidx3 = idx10 + idx8;
out[oidx1 - 1] = i1i + cr2;
out[oidx1] = i1r + ci2;
out[oidx2 - 1] = tr2 - tr3;
out[oidx2] = ti3 - ti2;
out[oidx3 - 1] = tr2 + tr3;
out[oidx3] = ti2 + ti3;
}
}
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. This method computes the full real inverse transform, i.e. you will get
the same result as from <code>complexInverse</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
public void realInverseFull(final float[] a, final int offa, boolean scale) {
final int twon = 2 * n;
switch (plan) {
case SPLIT_RADIX:
realInverse2(a, offa, scale);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n / 2 > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
Future<?>[] futures = new Future[nthreads];
int k = n / 2 / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n / 2 : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
int idx1, idx2;
for (int k = firstIdx; k < lastIdx; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
int idx1, idx2;
for (int k = 0; k < n / 2; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
a[offa + n] = -a[offa + 1];
a[offa + 1] = 0;
break;
case MIXED_RADIX:
rfftf(a, offa);
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
} else {
m = (n + 1) / 2;
}
for (int k = 1; k < m; k++) {
int idx1 = offa + 2 * k;
int idx2 = offa + twon - 2 * k;
a[idx1] = -a[idx1];
a[idx2 + 1] = -a[idx1];
a[idx2] = a[idx1 - 1];
}
for (int k = 1; k < n; k++) {
int idx = offa + n - k;
float tmp = a[idx + 1];
a[idx + 1] = a[idx];
a[idx] = tmp;
}
a[offa + 1] = 0;
break;
case BLUESTEIN:
bluestein_real_full(a, offa, 1);
if (scale) {
scale(n, a, offa, true);
}
break;
}
}
private void realInverse2(float[] a, int offa, boolean scale) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
float xi;
if (n > 4) {
cftfsub(n, a, offa, ip, nw, w);
rftbsub(n, a, offa, nc, w, nw);
} else if (n == 4) {
cftbsub(n, a, offa, ip, nw, w);
}
xi = a[offa] - a[offa + 1];
a[offa] += a[offa + 1];
a[offa + 1] = xi;
if (scale) {
scale(n, a, offa, false);
}
break;
case MIXED_RADIX:
rfftf(a, offa);
for (int k = n - 1; k >= 2; k--) {
int idx = offa + k;
float tmp = a[idx];
a[idx] = a[idx - 1];
a[idx - 1] = tmp;
}
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
for (int i = 1; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
} else {
m = (n - 1) / 2;
for (int i = 0; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
}
break;
case BLUESTEIN:
bluestein_real_inverse2(a, offa);
if (scale) {
scale(n, a, offa, false);
}
break;
}
}
private static int getReminder(int n, int[] factors) {
int reminder = n;
if (n <= 0) {
throw new IllegalArgumentException("n must be positive integer");
}
for (int i = 0; i < factors.length && reminder != 1; i++) {
int factor = factors[i];
while ((reminder % factor) == 0) {
reminder /= factor;
}
}
return reminder;
}
/* -------- initializing routines --------
/*---------------------------------------------------------
cffti: initialization of Complex FFT
--------------------------------------------------------
void cffti(int n, int offw) {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[offw + nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[offw + idx + 1] = wtable[offw + idx];
}
wtable[offw + 2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[offw + fourn] = n;
wtable[offw + 1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[offw + k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[offw + i - 1 + twon] = 1;
wtable[offw + i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[offw + idx - 1] = (float)Math.cos(arg);
wtable[offw + idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[offw + idx1 - 1] = wtable[offw + idx2 - 1];
wtable[offw + idx1] = wtable[offw + idx2];
}
}
l1 = l2;
}
}
void cffti() {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[idx + 1] = wtable[idx];
}
wtable[2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[fourn] = n;
wtable[1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[i - 1 + twon] = 1;
wtable[i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[idx - 1] = (float)Math.cos(arg);
wtable[idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[idx1 - 1] = wtable[idx2 - 1];
wtable[idx1] = wtable[idx2];
}
}
l1 = l2;
}
}
void rffti() {
if (n == 1)
return;
final int twon = 2 * n;
float argh;
int ntry = 0, i, j;
float argld;
int k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, is, nq, nr;
float arg;
int ido, ipm;
int nfm1;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
++j;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
++nf;
wtable_r[nf + 1 + twon] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + twon;
wtable_r[idx + 1] = wtable_r[idx];
}
wtable_r[2 + twon] = 2;
}
} while (nl != 1);
break;
}
wtable_r[twon] = n;
wtable_r[1 + twon] = nf;
argh = TWO_PI / (float) (n);
is = 0;
nfm1 = nf - 1;
l1 = 1;
if (nfm1 == 0)
return;
for (k1 = 1; k1 <= nfm1; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
ipm = ip - 1;
for (j = 1; j <= ipm; ++j) {
ld += l1;
i = is;
argld = (float) ld * argh;
fi = 0;
for (ii = 3; ii <= ido; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + n;
wtable_r[idx - 2] = (float)Math.cos(arg);
wtable_r[idx - 1] = (float)Math.sin(arg);
}
is += ido;
}
l1 = l2;
}
}
private void bluesteini() {
int k = 0;
float arg;
float pi_n = PI / n;
bk1[0] = 1;
bk1[1] = 0;
for (int i = 1; i < n; i++) {
k += 2 * i - 1;
if (k >= 2 * n)
k -= 2 * n;
arg = pi_n * k;
bk1[2 * i] = (float)Math.cos(arg);
bk1[2 * i + 1] = (float)Math.sin(arg);
}
float scale = (float)(1.0 / nBluestein);
bk2[0] = bk1[0] * scale;
bk2[1] = bk1[1] * scale;
for (int i = 2; i < 2 * n; i += 2) {
bk2[i] = bk1[i] * scale;
bk2[i + 1] = bk1[i + 1] * scale;
bk2[2 * nBluestein - i] = bk2[i];
bk2[2 * nBluestein - i + 1] = bk2[i + 1];
}
cftbsub(2 * nBluestein, bk2, 0, ip, nw, w);
}
private void makewt(int nw) {
int j, nwh, nw0, nw1;
float delta, wn4r, wk1r, wk1i, wk3r, wk3i;
float delta2, deltaj, deltaj3;
ip[0] = nw;
ip[1] = 1;
if (nw > 2) {
nwh = nw >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nwh);
delta2 = delta * 2;
wn4r = (float)Math.cos(delta * nwh);
w[0] = 1;
w[1] = wn4r;
if (nwh == 4) {
w[2] = (float)Math.cos(delta2);
w[3] = (float)Math.sin(delta2);
} else if (nwh > 4) {
makeipt(nw);
w[2] = (float)(0.5 / Math.cos(delta2));
w[3] = (float)(0.5 / Math.cos(delta * 6));
for (j = 4; j < nwh; j += 4) {
deltaj = delta * j;
deltaj3 = 3 * deltaj;
w[j] = (float)Math.cos(deltaj);
w[j + 1] = (float)Math.sin(deltaj);
w[j + 2] = (float)Math.cos(deltaj3);
w[j + 3] = (float)-Math.sin(deltaj3);
}
}
nw0 = 0;
while (nwh > 2) {
nw1 = nw0 + nwh;
nwh >>= 1;
w[nw1] = 1;
w[nw1 + 1] = wn4r;
if (nwh == 4) {
wk1r = w[nw0 + 4];
wk1i = w[nw0 + 5];
w[nw1 + 2] = wk1r;
w[nw1 + 3] = wk1i;
} else if (nwh > 4) {
wk1r = w[nw0 + 4];
wk3r = w[nw0 + 6];
w[nw1 + 2] = (float)(0.5 / wk1r);
w[nw1 + 3] = (float)(0.5 / wk3r);
for (j = 4; j < nwh; j += 4) {
int idx1 = nw0 + 2 * j;
int idx2 = nw1 + j;
wk1r = w[idx1];
wk1i = w[idx1 + 1];
wk3r = w[idx1 + 2];
wk3i = w[idx1 + 3];
w[idx2] = wk1r;
w[idx2 + 1] = wk1i;
w[idx2 + 2] = wk3r;
w[idx2 + 3] = wk3i;
}
}
nw0 = nw1;
}
}
}
private void makeipt(int nw) {
int j, l, m, m2, p, q;
ip[2] = 0;
ip[3] = 16;
m = 2;
for (l = nw; l > 32; l >>= 2) {
m2 = m << 1;
q = m2 << 3;
for (j = m; j < m2; j++) {
p = ip[j] << 2;
ip[m + j] = p;
ip[m2 + j] = p + q;
}
m = m2;
}
}
private void makect(int nc, float[] c, int startc) {
int j, nch;
float delta, deltaj;
ip[1] = nc;
if (nc > 1) {
nch = nc >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nch);
c[startc] = (float)Math.cos(delta * nch);
c[startc + nch] = (float)(0.5 * c[startc]);
for (j = 1; j < nch; j++) {
deltaj = delta * j;
c[startc + j] = (float)(0.5 * Math.cos(deltaj));
c[startc + nc - j] = (float)(0.5 * Math.sin(deltaj));
}
}
}
private void bluestein_complex(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_full(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_forward(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] + bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = -bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] + bk1[n] * ak[n];
}
}
private void bluestein_real_inverse(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
if (n % 2 == 0) {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n] = a[offa + 1] * bk1[n];
ak[n + 1] = a[offa + 1] * bk1[n + 1];
for (int i = n / 2 + 1; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
} else {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n - 1] = a[offa + n - 1] * bk1[n - 1] - a[offa + 1] * bk1[n];
ak[n] = a[offa + n - 1] * bk1[n] + a[offa + 1] * bk1[n - 1];
ak[n + 1] = a[offa + n - 1] * bk1[n + 1] + a[offa + 1] * bk1[n + 2];
ak[n + 2] = a[offa + n - 1] * bk1[n + 2] - a[offa + 1] * bk1[n + 1];
for (int i = (n - 1) / 2 + 2; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
}
private void bluestein_real_inverse2(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] - bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] - bk1[n] * ak[n];
}
}
/*---------------------------------------------------------
rfftf1: further processing of Real forward FFT
--------------------------------------------------------
void rfftf(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, kh, nf, ip, iw, ido, idl1;
final float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 1;
l2 = n;
iw = twon - 1;
for (int k1 = 1; k1 <= nf; ++k1) {
kh = nf - k1;
ip = (int) wtable_r[kh + 2 + twon];
l1 = l2 / ip;
ido = n / l2;
idl1 = ido * l1;
iw -= (ip - 1) * ido;
na = 1 - na;
switch (ip) {
case 2:
if (na == 0) {
radf2(ido, l1, a, offa, ch, 0, iw);
} else {
radf2(ido, l1, ch, 0, a, offa, iw);
}
break;
case 3:
if (na == 0) {
radf3(ido, l1, a, offa, ch, 0, iw);
} else {
radf3(ido, l1, ch, 0, a, offa, iw);
}
break;
case 4:
if (na == 0) {
radf4(ido, l1, a, offa, ch, 0, iw);
} else {
radf4(ido, l1, ch, 0, a, offa, iw);
}
break;
case 5:
if (na == 0) {
radf5(ido, l1, a, offa, ch, 0, iw);
} else {
radf5(ido, l1, ch, 0, a, offa, iw);
}
break;
default:
if (ido == 1)
na = 1 - na;
if (na == 0) {
radfg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
na = 1;
} else {
radfg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
na = 0;
}
break;
}
l2 = l1;
}
if (na == 1)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*---------------------------------------------------------
rfftb1: further processing of Real backward FFT
--------------------------------------------------------
void rfftb(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, nf, ip, iw, ido, idl1;
float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 0;
l1 = 1;
iw = n;
for (int k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
l2 = ip * l1;
ido = n / l2;
idl1 = ido * l1;
switch (ip) {
case 2:
if (na == 0) {
radb2(ido, l1, a, offa, ch, 0, iw);
} else {
radb2(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
radb3(ido, l1, a, offa, ch, 0, iw);
} else {
radb3(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 4:
if (na == 0) {
radb4(ido, l1, a, offa, ch, 0, iw);
} else {
radb4(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
radb5(ido, l1, a, offa, ch, 0, iw);
} else {
radb5(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
default:
if (na == 0) {
radbg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
} else {
radbg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
}
if (ido == 1)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * ido;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*-------------------------------------------------
radf2: Real FFT's forward processing of factor 2
-------------------------------------------------
void radf2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic, idx0, idx1, idx2, idx3, idx4;
float t1i, t1r, w1r, w1i;
int iw1;
iw1 = offset;
idx0 = l1 * ido;
idx1 = 2 * ido;
for (int k = 0; k < l1; k++) {
int oidx1 = out_off + k * idx1;
int oidx2 = oidx1 + idx1 - 1;
int iidx1 = in_off + k * ido;
int iidx2 = iidx1 + idx0;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx2] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
idx2 = 2 * idx1;
idx3 = idx2 + ido;
idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int oidx1 = out_off + i + idx2;
int oidx2 = out_off + ic + idx3;
int iidx1 = in_off + i + idx1;
int iidx2 = in_off + i + idx4;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
t1r = w1r * a2i + w1i * a2r;
t1i = w1r * a2r - w1i * a2i;
out[oidx1] = a1r + t1i;
out[oidx1 - 1] = a1i + t1r;
out[oidx2] = t1i - a1r;
out[oidx2 - 1] = a1i - t1r;
}
}
if (ido % 2 == 1)
return;
}
idx2 = 2 * idx1;
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
int oidx1 = out_off + idx2 + ido;
int iidx1 = in_off + ido - 1 + idx1;
out[oidx1] = -in[iidx1 + idx0];
out[oidx1 - 1] = in[iidx1];
}
}
/*-------------------------------------------------
radb2: Real FFT's backward processing of factor 2
-------------------------------------------------
void radb2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic;
float t1i, t1r, w1r, w1i;
int iw1 = offset;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int oidx1 = out_off + idx1;
int iidx1 = in_off + idx2;
int iidx2 = in_off + ido - 1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx1 + idx0] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx5 = i - 1 + iw1;
int idx6 = out_off + i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
w1r = wtable_r[idx5 - 1];
w1i = wtable_r[idx5];
int iidx1 = idx7 + idx2;
int iidx2 = idx8 + idx3;
int oidx1 = idx6 + idx1;
int oidx2 = idx6 + idx4;
t1r = in[iidx1 - 1] - in[iidx2 - 1];
t1i = in[iidx1] + in[iidx2];
float i1i = in[iidx1];
float i1r = in[iidx1 - 1];
float i2i = in[iidx2];
float i2r = in[iidx2 - 1];
out[oidx1 - 1] = i1r + i2r;
out[oidx1] = i1i - i2i;
out[oidx2 - 1] = w1r * t1r - w1i * t1i;
out[oidx2] = w1r * t1i + w1i * t1r;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int oidx1 = out_off + ido - 1 + idx1;
int iidx1 = in_off + idx2 + ido;
out[oidx1] = 2 * in[iidx1 - 1];
out[oidx1 + idx0] = -2 * in[iidx1];
}
}
/*-------------------------------------------------
radf3: Real FFT's forward processing of factor 3
------------------------------------------------- | FloatFFT::radf3 | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
void radb3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, ci3, di2, di3, cr2, cr3, dr2, dr3, ti2, tr2, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int iidx1 = in_off + 3 * idx1;
int iidx2 = iidx1 + 2 * ido;
float i1i = in[iidx1];
tr2 = 2 * in[iidx2 - 1];
cr2 = i1i + taur * tr2;
ci3 = 2 * taui * in[iidx2];
out[out_off + idx1] = i1i + tr2;
out[out_off + (k + l1) * ido] = cr2 - ci3;
out[out_off + (k + 2 * l1) * ido] = cr2 + ci3;
}
if (ido == 1)
return;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 3 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx1 + idx0;
int idx6 = idx5 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
int idx9 = out_off + i;
int iidx1 = idx7 + idx2;
int iidx2 = idx7 + idx4;
int iidx3 = idx8 + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
tr2 = i2i + i3i;
cr2 = i1i + taur * tr2;
ti2 = i2r - i3r;
ci2 = i1r + taur * ti2;
cr3 = taui * (i2i - i3i);
ci3 = taui * (i2r + i3r);
dr2 = cr2 - ci3;
dr3 = cr2 + ci3;
di2 = ci2 + cr3;
di3 = ci2 - cr3;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int oidx1 = idx9 + idx1;
int oidx2 = idx9 + idx5;
int oidx3 = idx9 + idx6;
out[oidx1 - 1] = i1i + tr2;
out[oidx1] = i1r + ti2;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
}
}
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. This method computes the full real inverse transform, i.e. you will get
the same result as from <code>complexInverse</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
public void realInverseFull(final float[] a, final int offa, boolean scale) {
final int twon = 2 * n;
switch (plan) {
case SPLIT_RADIX:
realInverse2(a, offa, scale);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n / 2 > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
Future<?>[] futures = new Future[nthreads];
int k = n / 2 / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n / 2 : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
int idx1, idx2;
for (int k = firstIdx; k < lastIdx; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
int idx1, idx2;
for (int k = 0; k < n / 2; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
a[offa + n] = -a[offa + 1];
a[offa + 1] = 0;
break;
case MIXED_RADIX:
rfftf(a, offa);
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
} else {
m = (n + 1) / 2;
}
for (int k = 1; k < m; k++) {
int idx1 = offa + 2 * k;
int idx2 = offa + twon - 2 * k;
a[idx1] = -a[idx1];
a[idx2 + 1] = -a[idx1];
a[idx2] = a[idx1 - 1];
}
for (int k = 1; k < n; k++) {
int idx = offa + n - k;
float tmp = a[idx + 1];
a[idx + 1] = a[idx];
a[idx] = tmp;
}
a[offa + 1] = 0;
break;
case BLUESTEIN:
bluestein_real_full(a, offa, 1);
if (scale) {
scale(n, a, offa, true);
}
break;
}
}
private void realInverse2(float[] a, int offa, boolean scale) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
float xi;
if (n > 4) {
cftfsub(n, a, offa, ip, nw, w);
rftbsub(n, a, offa, nc, w, nw);
} else if (n == 4) {
cftbsub(n, a, offa, ip, nw, w);
}
xi = a[offa] - a[offa + 1];
a[offa] += a[offa + 1];
a[offa + 1] = xi;
if (scale) {
scale(n, a, offa, false);
}
break;
case MIXED_RADIX:
rfftf(a, offa);
for (int k = n - 1; k >= 2; k--) {
int idx = offa + k;
float tmp = a[idx];
a[idx] = a[idx - 1];
a[idx - 1] = tmp;
}
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
for (int i = 1; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
} else {
m = (n - 1) / 2;
for (int i = 0; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
}
break;
case BLUESTEIN:
bluestein_real_inverse2(a, offa);
if (scale) {
scale(n, a, offa, false);
}
break;
}
}
private static int getReminder(int n, int[] factors) {
int reminder = n;
if (n <= 0) {
throw new IllegalArgumentException("n must be positive integer");
}
for (int i = 0; i < factors.length && reminder != 1; i++) {
int factor = factors[i];
while ((reminder % factor) == 0) {
reminder /= factor;
}
}
return reminder;
}
/* -------- initializing routines --------
/*---------------------------------------------------------
cffti: initialization of Complex FFT
--------------------------------------------------------
void cffti(int n, int offw) {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[offw + nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[offw + idx + 1] = wtable[offw + idx];
}
wtable[offw + 2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[offw + fourn] = n;
wtable[offw + 1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[offw + k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[offw + i - 1 + twon] = 1;
wtable[offw + i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[offw + idx - 1] = (float)Math.cos(arg);
wtable[offw + idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[offw + idx1 - 1] = wtable[offw + idx2 - 1];
wtable[offw + idx1] = wtable[offw + idx2];
}
}
l1 = l2;
}
}
void cffti() {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[idx + 1] = wtable[idx];
}
wtable[2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[fourn] = n;
wtable[1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[i - 1 + twon] = 1;
wtable[i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[idx - 1] = (float)Math.cos(arg);
wtable[idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[idx1 - 1] = wtable[idx2 - 1];
wtable[idx1] = wtable[idx2];
}
}
l1 = l2;
}
}
void rffti() {
if (n == 1)
return;
final int twon = 2 * n;
float argh;
int ntry = 0, i, j;
float argld;
int k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, is, nq, nr;
float arg;
int ido, ipm;
int nfm1;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
++j;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
++nf;
wtable_r[nf + 1 + twon] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + twon;
wtable_r[idx + 1] = wtable_r[idx];
}
wtable_r[2 + twon] = 2;
}
} while (nl != 1);
break;
}
wtable_r[twon] = n;
wtable_r[1 + twon] = nf;
argh = TWO_PI / (float) (n);
is = 0;
nfm1 = nf - 1;
l1 = 1;
if (nfm1 == 0)
return;
for (k1 = 1; k1 <= nfm1; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
ipm = ip - 1;
for (j = 1; j <= ipm; ++j) {
ld += l1;
i = is;
argld = (float) ld * argh;
fi = 0;
for (ii = 3; ii <= ido; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + n;
wtable_r[idx - 2] = (float)Math.cos(arg);
wtable_r[idx - 1] = (float)Math.sin(arg);
}
is += ido;
}
l1 = l2;
}
}
private void bluesteini() {
int k = 0;
float arg;
float pi_n = PI / n;
bk1[0] = 1;
bk1[1] = 0;
for (int i = 1; i < n; i++) {
k += 2 * i - 1;
if (k >= 2 * n)
k -= 2 * n;
arg = pi_n * k;
bk1[2 * i] = (float)Math.cos(arg);
bk1[2 * i + 1] = (float)Math.sin(arg);
}
float scale = (float)(1.0 / nBluestein);
bk2[0] = bk1[0] * scale;
bk2[1] = bk1[1] * scale;
for (int i = 2; i < 2 * n; i += 2) {
bk2[i] = bk1[i] * scale;
bk2[i + 1] = bk1[i + 1] * scale;
bk2[2 * nBluestein - i] = bk2[i];
bk2[2 * nBluestein - i + 1] = bk2[i + 1];
}
cftbsub(2 * nBluestein, bk2, 0, ip, nw, w);
}
private void makewt(int nw) {
int j, nwh, nw0, nw1;
float delta, wn4r, wk1r, wk1i, wk3r, wk3i;
float delta2, deltaj, deltaj3;
ip[0] = nw;
ip[1] = 1;
if (nw > 2) {
nwh = nw >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nwh);
delta2 = delta * 2;
wn4r = (float)Math.cos(delta * nwh);
w[0] = 1;
w[1] = wn4r;
if (nwh == 4) {
w[2] = (float)Math.cos(delta2);
w[3] = (float)Math.sin(delta2);
} else if (nwh > 4) {
makeipt(nw);
w[2] = (float)(0.5 / Math.cos(delta2));
w[3] = (float)(0.5 / Math.cos(delta * 6));
for (j = 4; j < nwh; j += 4) {
deltaj = delta * j;
deltaj3 = 3 * deltaj;
w[j] = (float)Math.cos(deltaj);
w[j + 1] = (float)Math.sin(deltaj);
w[j + 2] = (float)Math.cos(deltaj3);
w[j + 3] = (float)-Math.sin(deltaj3);
}
}
nw0 = 0;
while (nwh > 2) {
nw1 = nw0 + nwh;
nwh >>= 1;
w[nw1] = 1;
w[nw1 + 1] = wn4r;
if (nwh == 4) {
wk1r = w[nw0 + 4];
wk1i = w[nw0 + 5];
w[nw1 + 2] = wk1r;
w[nw1 + 3] = wk1i;
} else if (nwh > 4) {
wk1r = w[nw0 + 4];
wk3r = w[nw0 + 6];
w[nw1 + 2] = (float)(0.5 / wk1r);
w[nw1 + 3] = (float)(0.5 / wk3r);
for (j = 4; j < nwh; j += 4) {
int idx1 = nw0 + 2 * j;
int idx2 = nw1 + j;
wk1r = w[idx1];
wk1i = w[idx1 + 1];
wk3r = w[idx1 + 2];
wk3i = w[idx1 + 3];
w[idx2] = wk1r;
w[idx2 + 1] = wk1i;
w[idx2 + 2] = wk3r;
w[idx2 + 3] = wk3i;
}
}
nw0 = nw1;
}
}
}
private void makeipt(int nw) {
int j, l, m, m2, p, q;
ip[2] = 0;
ip[3] = 16;
m = 2;
for (l = nw; l > 32; l >>= 2) {
m2 = m << 1;
q = m2 << 3;
for (j = m; j < m2; j++) {
p = ip[j] << 2;
ip[m + j] = p;
ip[m2 + j] = p + q;
}
m = m2;
}
}
private void makect(int nc, float[] c, int startc) {
int j, nch;
float delta, deltaj;
ip[1] = nc;
if (nc > 1) {
nch = nc >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nch);
c[startc] = (float)Math.cos(delta * nch);
c[startc + nch] = (float)(0.5 * c[startc]);
for (j = 1; j < nch; j++) {
deltaj = delta * j;
c[startc + j] = (float)(0.5 * Math.cos(deltaj));
c[startc + nc - j] = (float)(0.5 * Math.sin(deltaj));
}
}
}
private void bluestein_complex(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_full(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_forward(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] + bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = -bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] + bk1[n] * ak[n];
}
}
private void bluestein_real_inverse(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
if (n % 2 == 0) {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n] = a[offa + 1] * bk1[n];
ak[n + 1] = a[offa + 1] * bk1[n + 1];
for (int i = n / 2 + 1; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
} else {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n - 1] = a[offa + n - 1] * bk1[n - 1] - a[offa + 1] * bk1[n];
ak[n] = a[offa + n - 1] * bk1[n] + a[offa + 1] * bk1[n - 1];
ak[n + 1] = a[offa + n - 1] * bk1[n + 1] + a[offa + 1] * bk1[n + 2];
ak[n + 2] = a[offa + n - 1] * bk1[n + 2] - a[offa + 1] * bk1[n + 1];
for (int i = (n - 1) / 2 + 2; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
}
private void bluestein_real_inverse2(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] - bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] - bk1[n] * ak[n];
}
}
/*---------------------------------------------------------
rfftf1: further processing of Real forward FFT
--------------------------------------------------------
void rfftf(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, kh, nf, ip, iw, ido, idl1;
final float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 1;
l2 = n;
iw = twon - 1;
for (int k1 = 1; k1 <= nf; ++k1) {
kh = nf - k1;
ip = (int) wtable_r[kh + 2 + twon];
l1 = l2 / ip;
ido = n / l2;
idl1 = ido * l1;
iw -= (ip - 1) * ido;
na = 1 - na;
switch (ip) {
case 2:
if (na == 0) {
radf2(ido, l1, a, offa, ch, 0, iw);
} else {
radf2(ido, l1, ch, 0, a, offa, iw);
}
break;
case 3:
if (na == 0) {
radf3(ido, l1, a, offa, ch, 0, iw);
} else {
radf3(ido, l1, ch, 0, a, offa, iw);
}
break;
case 4:
if (na == 0) {
radf4(ido, l1, a, offa, ch, 0, iw);
} else {
radf4(ido, l1, ch, 0, a, offa, iw);
}
break;
case 5:
if (na == 0) {
radf5(ido, l1, a, offa, ch, 0, iw);
} else {
radf5(ido, l1, ch, 0, a, offa, iw);
}
break;
default:
if (ido == 1)
na = 1 - na;
if (na == 0) {
radfg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
na = 1;
} else {
radfg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
na = 0;
}
break;
}
l2 = l1;
}
if (na == 1)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*---------------------------------------------------------
rfftb1: further processing of Real backward FFT
--------------------------------------------------------
void rfftb(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, nf, ip, iw, ido, idl1;
float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 0;
l1 = 1;
iw = n;
for (int k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
l2 = ip * l1;
ido = n / l2;
idl1 = ido * l1;
switch (ip) {
case 2:
if (na == 0) {
radb2(ido, l1, a, offa, ch, 0, iw);
} else {
radb2(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
radb3(ido, l1, a, offa, ch, 0, iw);
} else {
radb3(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 4:
if (na == 0) {
radb4(ido, l1, a, offa, ch, 0, iw);
} else {
radb4(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
radb5(ido, l1, a, offa, ch, 0, iw);
} else {
radb5(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
default:
if (na == 0) {
radbg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
} else {
radbg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
}
if (ido == 1)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * ido;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*-------------------------------------------------
radf2: Real FFT's forward processing of factor 2
-------------------------------------------------
void radf2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic, idx0, idx1, idx2, idx3, idx4;
float t1i, t1r, w1r, w1i;
int iw1;
iw1 = offset;
idx0 = l1 * ido;
idx1 = 2 * ido;
for (int k = 0; k < l1; k++) {
int oidx1 = out_off + k * idx1;
int oidx2 = oidx1 + idx1 - 1;
int iidx1 = in_off + k * ido;
int iidx2 = iidx1 + idx0;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx2] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
idx2 = 2 * idx1;
idx3 = idx2 + ido;
idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int oidx1 = out_off + i + idx2;
int oidx2 = out_off + ic + idx3;
int iidx1 = in_off + i + idx1;
int iidx2 = in_off + i + idx4;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
t1r = w1r * a2i + w1i * a2r;
t1i = w1r * a2r - w1i * a2i;
out[oidx1] = a1r + t1i;
out[oidx1 - 1] = a1i + t1r;
out[oidx2] = t1i - a1r;
out[oidx2 - 1] = a1i - t1r;
}
}
if (ido % 2 == 1)
return;
}
idx2 = 2 * idx1;
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
int oidx1 = out_off + idx2 + ido;
int iidx1 = in_off + ido - 1 + idx1;
out[oidx1] = -in[iidx1 + idx0];
out[oidx1 - 1] = in[iidx1];
}
}
/*-------------------------------------------------
radb2: Real FFT's backward processing of factor 2
-------------------------------------------------
void radb2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic;
float t1i, t1r, w1r, w1i;
int iw1 = offset;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int oidx1 = out_off + idx1;
int iidx1 = in_off + idx2;
int iidx2 = in_off + ido - 1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx1 + idx0] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx5 = i - 1 + iw1;
int idx6 = out_off + i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
w1r = wtable_r[idx5 - 1];
w1i = wtable_r[idx5];
int iidx1 = idx7 + idx2;
int iidx2 = idx8 + idx3;
int oidx1 = idx6 + idx1;
int oidx2 = idx6 + idx4;
t1r = in[iidx1 - 1] - in[iidx2 - 1];
t1i = in[iidx1] + in[iidx2];
float i1i = in[iidx1];
float i1r = in[iidx1 - 1];
float i2i = in[iidx2];
float i2r = in[iidx2 - 1];
out[oidx1 - 1] = i1r + i2r;
out[oidx1] = i1i - i2i;
out[oidx2 - 1] = w1r * t1r - w1i * t1i;
out[oidx2] = w1r * t1i + w1i * t1r;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int oidx1 = out_off + ido - 1 + idx1;
int iidx1 = in_off + idx2 + ido;
out[oidx1] = 2 * in[iidx1 - 1];
out[oidx1 + idx0] = -2 * in[iidx1];
}
}
/*-------------------------------------------------
radf3: Real FFT's forward processing of factor 3
-------------------------------------------------
void radf3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, di2, di3, cr2, dr2, dr3, ti2, ti3, tr2, tr3, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx3 = 2 * idx0;
int idx4 = (3 * k + 1) * ido;
int iidx1 = in_off + idx1;
int iidx2 = iidx1 + idx0;
int iidx3 = iidx1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
float i3r = in[iidx3];
cr2 = i2r + i3r;
out[out_off + 3 * idx1] = i1r + cr2;
out[out_off + idx4 + ido] = taui * (i3r - i2r);
out[out_off + ido - 1 + idx4] = i1r + taur * cr2;
}
if (ido == 1)
return;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int idx4 = 3 * idx3;
int idx5 = idx3 + idx0;
int idx6 = idx5 + idx0;
int idx7 = idx4 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx3;
int iidx2 = idx9 + idx5;
int iidx3 = idx9 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
cr2 = dr2 + dr3;
ci2 = di2 + di3;
tr2 = i1i + taur * cr2;
ti2 = i1r + taur * ci2;
tr3 = taui * (di2 - di3);
ti3 = taui * (dr3 - dr2);
int oidx1 = idx10 + idx4;
int oidx2 = idx11 + idx7;
int oidx3 = idx10 + idx8;
out[oidx1 - 1] = i1i + cr2;
out[oidx1] = i1r + ci2;
out[oidx2 - 1] = tr2 - tr3;
out[oidx2] = ti3 - ti2;
out[oidx3 - 1] = tr2 + tr3;
out[oidx3] = ti2 + ti3;
}
}
}
/*-------------------------------------------------
radb3: Real FFT's backward processing of factor 3
------------------------------------------------- | FloatFFT::radb3 | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
void radf4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float hsqt2 = 0.707106781186547572737310929369414225f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = offset + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx3];
float i3r = in[in_off + idx4];
float i4r = in[in_off + idx5];
tr1 = i2r + i4r;
tr2 = i1r + i3r;
int oidx1 = out_off + idx2;
int oidx2 = out_off + idx6 + ido;
out[oidx1] = tr1 + tr2;
out[oidx2 - 1 + ido + ido] = tr2 - tr1;
out[oidx2 - 1] = i1r - i3r;
out[oidx2] = i4r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx1;
int iidx2 = idx9 + idx2;
int iidx3 = idx9 + idx3;
int iidx4 = idx9 + idx4;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
cr2 = w1r * i2i + w1i * i2r;
ci2 = w1r * i2r - w1i * i2i;
cr3 = w2r * i3i + w2i * i3r;
ci3 = w2r * i3r - w2i * i3i;
cr4 = w3r * i4i + w3i * i4r;
ci4 = w3r * i4r - w3i * i4i;
tr1 = cr2 + cr4;
tr4 = cr4 - cr2;
ti1 = ci2 + ci4;
ti4 = ci2 - ci4;
ti2 = i1r + ci3;
ti3 = i1r - ci3;
tr2 = i1i + cr3;
tr3 = i1i - cr3;
int oidx1 = idx10 + idx5;
int oidx2 = idx11 + idx6;
int oidx3 = idx10 + idx7;
int oidx4 = idx11 + idx8;
out[oidx1 - 1] = tr1 + tr2;
out[oidx4 - 1] = tr2 - tr1;
out[oidx1] = ti1 + ti2;
out[oidx4] = ti1 - ti2;
out[oidx3 - 1] = ti4 + tr3;
out[oidx2 - 1] = tr3 - ti4;
out[oidx3] = tr4 + ti3;
out[oidx2] = tr4 - ti3;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1i = in[idx9 - 1 + idx1];
float i2i = in[idx9 - 1 + idx3];
float i3i = in[idx9 - 1 + idx4];
float i4i = in[idx9 - 1 + idx5];
ti1 = -hsqt2 * (i2i + i4i);
tr1 = hsqt2 * (i2i - i4i);
out[idx10 - 1 + idx2] = tr1 + i1i;
out[idx10 - 1 + idx7] = i1i - tr1;
out[out_off + idx6] = ti1 - i3i;
out[out_off + idx8] = ti1 + i3i;
}
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. This method computes the full real inverse transform, i.e. you will get
the same result as from <code>complexInverse</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
public void realInverseFull(final float[] a, final int offa, boolean scale) {
final int twon = 2 * n;
switch (plan) {
case SPLIT_RADIX:
realInverse2(a, offa, scale);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n / 2 > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
Future<?>[] futures = new Future[nthreads];
int k = n / 2 / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n / 2 : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
int idx1, idx2;
for (int k = firstIdx; k < lastIdx; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
int idx1, idx2;
for (int k = 0; k < n / 2; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
a[offa + n] = -a[offa + 1];
a[offa + 1] = 0;
break;
case MIXED_RADIX:
rfftf(a, offa);
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
} else {
m = (n + 1) / 2;
}
for (int k = 1; k < m; k++) {
int idx1 = offa + 2 * k;
int idx2 = offa + twon - 2 * k;
a[idx1] = -a[idx1];
a[idx2 + 1] = -a[idx1];
a[idx2] = a[idx1 - 1];
}
for (int k = 1; k < n; k++) {
int idx = offa + n - k;
float tmp = a[idx + 1];
a[idx + 1] = a[idx];
a[idx] = tmp;
}
a[offa + 1] = 0;
break;
case BLUESTEIN:
bluestein_real_full(a, offa, 1);
if (scale) {
scale(n, a, offa, true);
}
break;
}
}
private void realInverse2(float[] a, int offa, boolean scale) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
float xi;
if (n > 4) {
cftfsub(n, a, offa, ip, nw, w);
rftbsub(n, a, offa, nc, w, nw);
} else if (n == 4) {
cftbsub(n, a, offa, ip, nw, w);
}
xi = a[offa] - a[offa + 1];
a[offa] += a[offa + 1];
a[offa + 1] = xi;
if (scale) {
scale(n, a, offa, false);
}
break;
case MIXED_RADIX:
rfftf(a, offa);
for (int k = n - 1; k >= 2; k--) {
int idx = offa + k;
float tmp = a[idx];
a[idx] = a[idx - 1];
a[idx - 1] = tmp;
}
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
for (int i = 1; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
} else {
m = (n - 1) / 2;
for (int i = 0; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
}
break;
case BLUESTEIN:
bluestein_real_inverse2(a, offa);
if (scale) {
scale(n, a, offa, false);
}
break;
}
}
private static int getReminder(int n, int[] factors) {
int reminder = n;
if (n <= 0) {
throw new IllegalArgumentException("n must be positive integer");
}
for (int i = 0; i < factors.length && reminder != 1; i++) {
int factor = factors[i];
while ((reminder % factor) == 0) {
reminder /= factor;
}
}
return reminder;
}
/* -------- initializing routines --------
/*---------------------------------------------------------
cffti: initialization of Complex FFT
--------------------------------------------------------
void cffti(int n, int offw) {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[offw + nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[offw + idx + 1] = wtable[offw + idx];
}
wtable[offw + 2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[offw + fourn] = n;
wtable[offw + 1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[offw + k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[offw + i - 1 + twon] = 1;
wtable[offw + i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[offw + idx - 1] = (float)Math.cos(arg);
wtable[offw + idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[offw + idx1 - 1] = wtable[offw + idx2 - 1];
wtable[offw + idx1] = wtable[offw + idx2];
}
}
l1 = l2;
}
}
void cffti() {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[idx + 1] = wtable[idx];
}
wtable[2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[fourn] = n;
wtable[1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[i - 1 + twon] = 1;
wtable[i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[idx - 1] = (float)Math.cos(arg);
wtable[idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[idx1 - 1] = wtable[idx2 - 1];
wtable[idx1] = wtable[idx2];
}
}
l1 = l2;
}
}
void rffti() {
if (n == 1)
return;
final int twon = 2 * n;
float argh;
int ntry = 0, i, j;
float argld;
int k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, is, nq, nr;
float arg;
int ido, ipm;
int nfm1;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
++j;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
++nf;
wtable_r[nf + 1 + twon] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + twon;
wtable_r[idx + 1] = wtable_r[idx];
}
wtable_r[2 + twon] = 2;
}
} while (nl != 1);
break;
}
wtable_r[twon] = n;
wtable_r[1 + twon] = nf;
argh = TWO_PI / (float) (n);
is = 0;
nfm1 = nf - 1;
l1 = 1;
if (nfm1 == 0)
return;
for (k1 = 1; k1 <= nfm1; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
ipm = ip - 1;
for (j = 1; j <= ipm; ++j) {
ld += l1;
i = is;
argld = (float) ld * argh;
fi = 0;
for (ii = 3; ii <= ido; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + n;
wtable_r[idx - 2] = (float)Math.cos(arg);
wtable_r[idx - 1] = (float)Math.sin(arg);
}
is += ido;
}
l1 = l2;
}
}
private void bluesteini() {
int k = 0;
float arg;
float pi_n = PI / n;
bk1[0] = 1;
bk1[1] = 0;
for (int i = 1; i < n; i++) {
k += 2 * i - 1;
if (k >= 2 * n)
k -= 2 * n;
arg = pi_n * k;
bk1[2 * i] = (float)Math.cos(arg);
bk1[2 * i + 1] = (float)Math.sin(arg);
}
float scale = (float)(1.0 / nBluestein);
bk2[0] = bk1[0] * scale;
bk2[1] = bk1[1] * scale;
for (int i = 2; i < 2 * n; i += 2) {
bk2[i] = bk1[i] * scale;
bk2[i + 1] = bk1[i + 1] * scale;
bk2[2 * nBluestein - i] = bk2[i];
bk2[2 * nBluestein - i + 1] = bk2[i + 1];
}
cftbsub(2 * nBluestein, bk2, 0, ip, nw, w);
}
private void makewt(int nw) {
int j, nwh, nw0, nw1;
float delta, wn4r, wk1r, wk1i, wk3r, wk3i;
float delta2, deltaj, deltaj3;
ip[0] = nw;
ip[1] = 1;
if (nw > 2) {
nwh = nw >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nwh);
delta2 = delta * 2;
wn4r = (float)Math.cos(delta * nwh);
w[0] = 1;
w[1] = wn4r;
if (nwh == 4) {
w[2] = (float)Math.cos(delta2);
w[3] = (float)Math.sin(delta2);
} else if (nwh > 4) {
makeipt(nw);
w[2] = (float)(0.5 / Math.cos(delta2));
w[3] = (float)(0.5 / Math.cos(delta * 6));
for (j = 4; j < nwh; j += 4) {
deltaj = delta * j;
deltaj3 = 3 * deltaj;
w[j] = (float)Math.cos(deltaj);
w[j + 1] = (float)Math.sin(deltaj);
w[j + 2] = (float)Math.cos(deltaj3);
w[j + 3] = (float)-Math.sin(deltaj3);
}
}
nw0 = 0;
while (nwh > 2) {
nw1 = nw0 + nwh;
nwh >>= 1;
w[nw1] = 1;
w[nw1 + 1] = wn4r;
if (nwh == 4) {
wk1r = w[nw0 + 4];
wk1i = w[nw0 + 5];
w[nw1 + 2] = wk1r;
w[nw1 + 3] = wk1i;
} else if (nwh > 4) {
wk1r = w[nw0 + 4];
wk3r = w[nw0 + 6];
w[nw1 + 2] = (float)(0.5 / wk1r);
w[nw1 + 3] = (float)(0.5 / wk3r);
for (j = 4; j < nwh; j += 4) {
int idx1 = nw0 + 2 * j;
int idx2 = nw1 + j;
wk1r = w[idx1];
wk1i = w[idx1 + 1];
wk3r = w[idx1 + 2];
wk3i = w[idx1 + 3];
w[idx2] = wk1r;
w[idx2 + 1] = wk1i;
w[idx2 + 2] = wk3r;
w[idx2 + 3] = wk3i;
}
}
nw0 = nw1;
}
}
}
private void makeipt(int nw) {
int j, l, m, m2, p, q;
ip[2] = 0;
ip[3] = 16;
m = 2;
for (l = nw; l > 32; l >>= 2) {
m2 = m << 1;
q = m2 << 3;
for (j = m; j < m2; j++) {
p = ip[j] << 2;
ip[m + j] = p;
ip[m2 + j] = p + q;
}
m = m2;
}
}
private void makect(int nc, float[] c, int startc) {
int j, nch;
float delta, deltaj;
ip[1] = nc;
if (nc > 1) {
nch = nc >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nch);
c[startc] = (float)Math.cos(delta * nch);
c[startc + nch] = (float)(0.5 * c[startc]);
for (j = 1; j < nch; j++) {
deltaj = delta * j;
c[startc + j] = (float)(0.5 * Math.cos(deltaj));
c[startc + nc - j] = (float)(0.5 * Math.sin(deltaj));
}
}
}
private void bluestein_complex(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_full(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_forward(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] + bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = -bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] + bk1[n] * ak[n];
}
}
private void bluestein_real_inverse(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
if (n % 2 == 0) {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n] = a[offa + 1] * bk1[n];
ak[n + 1] = a[offa + 1] * bk1[n + 1];
for (int i = n / 2 + 1; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
} else {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n - 1] = a[offa + n - 1] * bk1[n - 1] - a[offa + 1] * bk1[n];
ak[n] = a[offa + n - 1] * bk1[n] + a[offa + 1] * bk1[n - 1];
ak[n + 1] = a[offa + n - 1] * bk1[n + 1] + a[offa + 1] * bk1[n + 2];
ak[n + 2] = a[offa + n - 1] * bk1[n + 2] - a[offa + 1] * bk1[n + 1];
for (int i = (n - 1) / 2 + 2; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
}
private void bluestein_real_inverse2(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] - bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] - bk1[n] * ak[n];
}
}
/*---------------------------------------------------------
rfftf1: further processing of Real forward FFT
--------------------------------------------------------
void rfftf(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, kh, nf, ip, iw, ido, idl1;
final float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 1;
l2 = n;
iw = twon - 1;
for (int k1 = 1; k1 <= nf; ++k1) {
kh = nf - k1;
ip = (int) wtable_r[kh + 2 + twon];
l1 = l2 / ip;
ido = n / l2;
idl1 = ido * l1;
iw -= (ip - 1) * ido;
na = 1 - na;
switch (ip) {
case 2:
if (na == 0) {
radf2(ido, l1, a, offa, ch, 0, iw);
} else {
radf2(ido, l1, ch, 0, a, offa, iw);
}
break;
case 3:
if (na == 0) {
radf3(ido, l1, a, offa, ch, 0, iw);
} else {
radf3(ido, l1, ch, 0, a, offa, iw);
}
break;
case 4:
if (na == 0) {
radf4(ido, l1, a, offa, ch, 0, iw);
} else {
radf4(ido, l1, ch, 0, a, offa, iw);
}
break;
case 5:
if (na == 0) {
radf5(ido, l1, a, offa, ch, 0, iw);
} else {
radf5(ido, l1, ch, 0, a, offa, iw);
}
break;
default:
if (ido == 1)
na = 1 - na;
if (na == 0) {
radfg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
na = 1;
} else {
radfg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
na = 0;
}
break;
}
l2 = l1;
}
if (na == 1)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*---------------------------------------------------------
rfftb1: further processing of Real backward FFT
--------------------------------------------------------
void rfftb(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, nf, ip, iw, ido, idl1;
float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 0;
l1 = 1;
iw = n;
for (int k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
l2 = ip * l1;
ido = n / l2;
idl1 = ido * l1;
switch (ip) {
case 2:
if (na == 0) {
radb2(ido, l1, a, offa, ch, 0, iw);
} else {
radb2(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
radb3(ido, l1, a, offa, ch, 0, iw);
} else {
radb3(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 4:
if (na == 0) {
radb4(ido, l1, a, offa, ch, 0, iw);
} else {
radb4(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
radb5(ido, l1, a, offa, ch, 0, iw);
} else {
radb5(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
default:
if (na == 0) {
radbg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
} else {
radbg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
}
if (ido == 1)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * ido;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*-------------------------------------------------
radf2: Real FFT's forward processing of factor 2
-------------------------------------------------
void radf2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic, idx0, idx1, idx2, idx3, idx4;
float t1i, t1r, w1r, w1i;
int iw1;
iw1 = offset;
idx0 = l1 * ido;
idx1 = 2 * ido;
for (int k = 0; k < l1; k++) {
int oidx1 = out_off + k * idx1;
int oidx2 = oidx1 + idx1 - 1;
int iidx1 = in_off + k * ido;
int iidx2 = iidx1 + idx0;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx2] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
idx2 = 2 * idx1;
idx3 = idx2 + ido;
idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int oidx1 = out_off + i + idx2;
int oidx2 = out_off + ic + idx3;
int iidx1 = in_off + i + idx1;
int iidx2 = in_off + i + idx4;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
t1r = w1r * a2i + w1i * a2r;
t1i = w1r * a2r - w1i * a2i;
out[oidx1] = a1r + t1i;
out[oidx1 - 1] = a1i + t1r;
out[oidx2] = t1i - a1r;
out[oidx2 - 1] = a1i - t1r;
}
}
if (ido % 2 == 1)
return;
}
idx2 = 2 * idx1;
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
int oidx1 = out_off + idx2 + ido;
int iidx1 = in_off + ido - 1 + idx1;
out[oidx1] = -in[iidx1 + idx0];
out[oidx1 - 1] = in[iidx1];
}
}
/*-------------------------------------------------
radb2: Real FFT's backward processing of factor 2
-------------------------------------------------
void radb2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic;
float t1i, t1r, w1r, w1i;
int iw1 = offset;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int oidx1 = out_off + idx1;
int iidx1 = in_off + idx2;
int iidx2 = in_off + ido - 1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx1 + idx0] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx5 = i - 1 + iw1;
int idx6 = out_off + i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
w1r = wtable_r[idx5 - 1];
w1i = wtable_r[idx5];
int iidx1 = idx7 + idx2;
int iidx2 = idx8 + idx3;
int oidx1 = idx6 + idx1;
int oidx2 = idx6 + idx4;
t1r = in[iidx1 - 1] - in[iidx2 - 1];
t1i = in[iidx1] + in[iidx2];
float i1i = in[iidx1];
float i1r = in[iidx1 - 1];
float i2i = in[iidx2];
float i2r = in[iidx2 - 1];
out[oidx1 - 1] = i1r + i2r;
out[oidx1] = i1i - i2i;
out[oidx2 - 1] = w1r * t1r - w1i * t1i;
out[oidx2] = w1r * t1i + w1i * t1r;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int oidx1 = out_off + ido - 1 + idx1;
int iidx1 = in_off + idx2 + ido;
out[oidx1] = 2 * in[iidx1 - 1];
out[oidx1 + idx0] = -2 * in[iidx1];
}
}
/*-------------------------------------------------
radf3: Real FFT's forward processing of factor 3
-------------------------------------------------
void radf3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, di2, di3, cr2, dr2, dr3, ti2, ti3, tr2, tr3, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx3 = 2 * idx0;
int idx4 = (3 * k + 1) * ido;
int iidx1 = in_off + idx1;
int iidx2 = iidx1 + idx0;
int iidx3 = iidx1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
float i3r = in[iidx3];
cr2 = i2r + i3r;
out[out_off + 3 * idx1] = i1r + cr2;
out[out_off + idx4 + ido] = taui * (i3r - i2r);
out[out_off + ido - 1 + idx4] = i1r + taur * cr2;
}
if (ido == 1)
return;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int idx4 = 3 * idx3;
int idx5 = idx3 + idx0;
int idx6 = idx5 + idx0;
int idx7 = idx4 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx3;
int iidx2 = idx9 + idx5;
int iidx3 = idx9 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
cr2 = dr2 + dr3;
ci2 = di2 + di3;
tr2 = i1i + taur * cr2;
ti2 = i1r + taur * ci2;
tr3 = taui * (di2 - di3);
ti3 = taui * (dr3 - dr2);
int oidx1 = idx10 + idx4;
int oidx2 = idx11 + idx7;
int oidx3 = idx10 + idx8;
out[oidx1 - 1] = i1i + cr2;
out[oidx1] = i1r + ci2;
out[oidx2 - 1] = tr2 - tr3;
out[oidx2] = ti3 - ti2;
out[oidx3 - 1] = tr2 + tr3;
out[oidx3] = ti2 + ti3;
}
}
}
/*-------------------------------------------------
radb3: Real FFT's backward processing of factor 3
-------------------------------------------------
void radb3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, ci3, di2, di3, cr2, cr3, dr2, dr3, ti2, tr2, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int iidx1 = in_off + 3 * idx1;
int iidx2 = iidx1 + 2 * ido;
float i1i = in[iidx1];
tr2 = 2 * in[iidx2 - 1];
cr2 = i1i + taur * tr2;
ci3 = 2 * taui * in[iidx2];
out[out_off + idx1] = i1i + tr2;
out[out_off + (k + l1) * ido] = cr2 - ci3;
out[out_off + (k + 2 * l1) * ido] = cr2 + ci3;
}
if (ido == 1)
return;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 3 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx1 + idx0;
int idx6 = idx5 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
int idx9 = out_off + i;
int iidx1 = idx7 + idx2;
int iidx2 = idx7 + idx4;
int iidx3 = idx8 + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
tr2 = i2i + i3i;
cr2 = i1i + taur * tr2;
ti2 = i2r - i3r;
ci2 = i1r + taur * ti2;
cr3 = taui * (i2i - i3i);
ci3 = taui * (i2r + i3r);
dr2 = cr2 - ci3;
dr3 = cr2 + ci3;
di2 = ci2 + cr3;
di3 = ci2 - cr3;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int oidx1 = idx9 + idx1;
int oidx2 = idx9 + idx5;
int oidx3 = idx9 + idx6;
out[oidx1 - 1] = i1i + tr2;
out[oidx1] = i1r + ti2;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
}
}
}
/*-------------------------------------------------
radf4: Real FFT's forward processing of factor 4
------------------------------------------------- | FloatFFT::radf4 | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
void radb4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float sqrt2 = 1.41421356237309514547462185873882845f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4;
float ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
float i1r = in[in_off + idx2];
float i2r = in[in_off + idx7];
float i3r = in[in_off + ido - 1 + idx8];
float i4r = in[in_off + ido - 1 + idx6];
tr1 = i1r - i3r;
tr2 = i1r + i3r;
tr3 = i4r + i4r;
tr4 = i2r + i2r;
out[out_off + idx1] = tr2 + tr3;
out[out_off + idx3] = tr1 - tr4;
out[out_off + idx4] = tr2 - tr3;
out[out_off + idx5] = tr1 + tr4;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx12 = in_off + i;
int idx13 = in_off + ic;
int idx14 = out_off + i;
int iidx1 = idx12 + idx5;
int iidx2 = idx13 + idx6;
int iidx3 = idx12 + idx7;
int iidx4 = idx13 + idx8;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
ti1 = i1r + i4r;
ti2 = i1r - i4r;
ti3 = i3r - i2r;
tr4 = i3r + i2r;
tr1 = i1i - i4i;
tr2 = i1i + i4i;
ti4 = i3i - i2i;
tr3 = i3i + i2i;
cr3 = tr2 - tr3;
ci3 = ti2 - ti3;
cr2 = tr1 - tr4;
cr4 = tr1 + tr4;
ci2 = ti1 + ti4;
ci4 = ti1 - ti4;
int oidx1 = idx14 + idx1;
int oidx2 = idx14 + idx2;
int oidx3 = idx14 + idx3;
int oidx4 = idx14 + idx4;
out[oidx1 - 1] = tr2 + tr3;
out[oidx1] = ti2 + ti3;
out[oidx2 - 1] = w1r * cr2 - w1i * ci2;
out[oidx2] = w1r * ci2 + w1i * cr2;
out[oidx3 - 1] = w2r * cr3 - w2i * ci3;
out[oidx3] = w2r * ci3 + w2i * cr3;
out[oidx4 - 1] = w3r * cr4 - w3i * ci4;
out[oidx4] = w3r * ci4 + w3i * cr4;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1r = in[idx9 - 1 + idx2];
float i2r = in[idx9 - 1 + idx7];
float i3r = in[in_off + idx6];
float i4r = in[in_off + idx8];
ti1 = i3r + i4r;
ti2 = i4r - i3r;
tr1 = i1r - i2r;
tr2 = i1r + i2r;
out[idx10 - 1 + idx1] = tr2 + tr2;
out[idx10 - 1 + idx3] = sqrt2 * (tr1 - ti1);
out[idx10 - 1 + idx4] = ti2 + ti2;
out[idx10 - 1 + idx5] = -sqrt2 * (tr1 + ti1);
}
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. This method computes the full real inverse transform, i.e. you will get
the same result as from <code>complexInverse</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
public void realInverseFull(final float[] a, final int offa, boolean scale) {
final int twon = 2 * n;
switch (plan) {
case SPLIT_RADIX:
realInverse2(a, offa, scale);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n / 2 > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
Future<?>[] futures = new Future[nthreads];
int k = n / 2 / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n / 2 : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
int idx1, idx2;
for (int k = firstIdx; k < lastIdx; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
int idx1, idx2;
for (int k = 0; k < n / 2; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
a[offa + n] = -a[offa + 1];
a[offa + 1] = 0;
break;
case MIXED_RADIX:
rfftf(a, offa);
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
} else {
m = (n + 1) / 2;
}
for (int k = 1; k < m; k++) {
int idx1 = offa + 2 * k;
int idx2 = offa + twon - 2 * k;
a[idx1] = -a[idx1];
a[idx2 + 1] = -a[idx1];
a[idx2] = a[idx1 - 1];
}
for (int k = 1; k < n; k++) {
int idx = offa + n - k;
float tmp = a[idx + 1];
a[idx + 1] = a[idx];
a[idx] = tmp;
}
a[offa + 1] = 0;
break;
case BLUESTEIN:
bluestein_real_full(a, offa, 1);
if (scale) {
scale(n, a, offa, true);
}
break;
}
}
private void realInverse2(float[] a, int offa, boolean scale) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
float xi;
if (n > 4) {
cftfsub(n, a, offa, ip, nw, w);
rftbsub(n, a, offa, nc, w, nw);
} else if (n == 4) {
cftbsub(n, a, offa, ip, nw, w);
}
xi = a[offa] - a[offa + 1];
a[offa] += a[offa + 1];
a[offa + 1] = xi;
if (scale) {
scale(n, a, offa, false);
}
break;
case MIXED_RADIX:
rfftf(a, offa);
for (int k = n - 1; k >= 2; k--) {
int idx = offa + k;
float tmp = a[idx];
a[idx] = a[idx - 1];
a[idx - 1] = tmp;
}
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
for (int i = 1; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
} else {
m = (n - 1) / 2;
for (int i = 0; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
}
break;
case BLUESTEIN:
bluestein_real_inverse2(a, offa);
if (scale) {
scale(n, a, offa, false);
}
break;
}
}
private static int getReminder(int n, int[] factors) {
int reminder = n;
if (n <= 0) {
throw new IllegalArgumentException("n must be positive integer");
}
for (int i = 0; i < factors.length && reminder != 1; i++) {
int factor = factors[i];
while ((reminder % factor) == 0) {
reminder /= factor;
}
}
return reminder;
}
/* -------- initializing routines --------
/*---------------------------------------------------------
cffti: initialization of Complex FFT
--------------------------------------------------------
void cffti(int n, int offw) {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[offw + nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[offw + idx + 1] = wtable[offw + idx];
}
wtable[offw + 2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[offw + fourn] = n;
wtable[offw + 1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[offw + k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[offw + i - 1 + twon] = 1;
wtable[offw + i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[offw + idx - 1] = (float)Math.cos(arg);
wtable[offw + idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[offw + idx1 - 1] = wtable[offw + idx2 - 1];
wtable[offw + idx1] = wtable[offw + idx2];
}
}
l1 = l2;
}
}
void cffti() {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[idx + 1] = wtable[idx];
}
wtable[2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[fourn] = n;
wtable[1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[i - 1 + twon] = 1;
wtable[i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[idx - 1] = (float)Math.cos(arg);
wtable[idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[idx1 - 1] = wtable[idx2 - 1];
wtable[idx1] = wtable[idx2];
}
}
l1 = l2;
}
}
void rffti() {
if (n == 1)
return;
final int twon = 2 * n;
float argh;
int ntry = 0, i, j;
float argld;
int k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, is, nq, nr;
float arg;
int ido, ipm;
int nfm1;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
++j;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
++nf;
wtable_r[nf + 1 + twon] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + twon;
wtable_r[idx + 1] = wtable_r[idx];
}
wtable_r[2 + twon] = 2;
}
} while (nl != 1);
break;
}
wtable_r[twon] = n;
wtable_r[1 + twon] = nf;
argh = TWO_PI / (float) (n);
is = 0;
nfm1 = nf - 1;
l1 = 1;
if (nfm1 == 0)
return;
for (k1 = 1; k1 <= nfm1; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
ipm = ip - 1;
for (j = 1; j <= ipm; ++j) {
ld += l1;
i = is;
argld = (float) ld * argh;
fi = 0;
for (ii = 3; ii <= ido; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + n;
wtable_r[idx - 2] = (float)Math.cos(arg);
wtable_r[idx - 1] = (float)Math.sin(arg);
}
is += ido;
}
l1 = l2;
}
}
private void bluesteini() {
int k = 0;
float arg;
float pi_n = PI / n;
bk1[0] = 1;
bk1[1] = 0;
for (int i = 1; i < n; i++) {
k += 2 * i - 1;
if (k >= 2 * n)
k -= 2 * n;
arg = pi_n * k;
bk1[2 * i] = (float)Math.cos(arg);
bk1[2 * i + 1] = (float)Math.sin(arg);
}
float scale = (float)(1.0 / nBluestein);
bk2[0] = bk1[0] * scale;
bk2[1] = bk1[1] * scale;
for (int i = 2; i < 2 * n; i += 2) {
bk2[i] = bk1[i] * scale;
bk2[i + 1] = bk1[i + 1] * scale;
bk2[2 * nBluestein - i] = bk2[i];
bk2[2 * nBluestein - i + 1] = bk2[i + 1];
}
cftbsub(2 * nBluestein, bk2, 0, ip, nw, w);
}
private void makewt(int nw) {
int j, nwh, nw0, nw1;
float delta, wn4r, wk1r, wk1i, wk3r, wk3i;
float delta2, deltaj, deltaj3;
ip[0] = nw;
ip[1] = 1;
if (nw > 2) {
nwh = nw >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nwh);
delta2 = delta * 2;
wn4r = (float)Math.cos(delta * nwh);
w[0] = 1;
w[1] = wn4r;
if (nwh == 4) {
w[2] = (float)Math.cos(delta2);
w[3] = (float)Math.sin(delta2);
} else if (nwh > 4) {
makeipt(nw);
w[2] = (float)(0.5 / Math.cos(delta2));
w[3] = (float)(0.5 / Math.cos(delta * 6));
for (j = 4; j < nwh; j += 4) {
deltaj = delta * j;
deltaj3 = 3 * deltaj;
w[j] = (float)Math.cos(deltaj);
w[j + 1] = (float)Math.sin(deltaj);
w[j + 2] = (float)Math.cos(deltaj3);
w[j + 3] = (float)-Math.sin(deltaj3);
}
}
nw0 = 0;
while (nwh > 2) {
nw1 = nw0 + nwh;
nwh >>= 1;
w[nw1] = 1;
w[nw1 + 1] = wn4r;
if (nwh == 4) {
wk1r = w[nw0 + 4];
wk1i = w[nw0 + 5];
w[nw1 + 2] = wk1r;
w[nw1 + 3] = wk1i;
} else if (nwh > 4) {
wk1r = w[nw0 + 4];
wk3r = w[nw0 + 6];
w[nw1 + 2] = (float)(0.5 / wk1r);
w[nw1 + 3] = (float)(0.5 / wk3r);
for (j = 4; j < nwh; j += 4) {
int idx1 = nw0 + 2 * j;
int idx2 = nw1 + j;
wk1r = w[idx1];
wk1i = w[idx1 + 1];
wk3r = w[idx1 + 2];
wk3i = w[idx1 + 3];
w[idx2] = wk1r;
w[idx2 + 1] = wk1i;
w[idx2 + 2] = wk3r;
w[idx2 + 3] = wk3i;
}
}
nw0 = nw1;
}
}
}
private void makeipt(int nw) {
int j, l, m, m2, p, q;
ip[2] = 0;
ip[3] = 16;
m = 2;
for (l = nw; l > 32; l >>= 2) {
m2 = m << 1;
q = m2 << 3;
for (j = m; j < m2; j++) {
p = ip[j] << 2;
ip[m + j] = p;
ip[m2 + j] = p + q;
}
m = m2;
}
}
private void makect(int nc, float[] c, int startc) {
int j, nch;
float delta, deltaj;
ip[1] = nc;
if (nc > 1) {
nch = nc >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nch);
c[startc] = (float)Math.cos(delta * nch);
c[startc + nch] = (float)(0.5 * c[startc]);
for (j = 1; j < nch; j++) {
deltaj = delta * j;
c[startc + j] = (float)(0.5 * Math.cos(deltaj));
c[startc + nc - j] = (float)(0.5 * Math.sin(deltaj));
}
}
}
private void bluestein_complex(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_full(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_forward(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] + bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = -bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] + bk1[n] * ak[n];
}
}
private void bluestein_real_inverse(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
if (n % 2 == 0) {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n] = a[offa + 1] * bk1[n];
ak[n + 1] = a[offa + 1] * bk1[n + 1];
for (int i = n / 2 + 1; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
} else {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n - 1] = a[offa + n - 1] * bk1[n - 1] - a[offa + 1] * bk1[n];
ak[n] = a[offa + n - 1] * bk1[n] + a[offa + 1] * bk1[n - 1];
ak[n + 1] = a[offa + n - 1] * bk1[n + 1] + a[offa + 1] * bk1[n + 2];
ak[n + 2] = a[offa + n - 1] * bk1[n + 2] - a[offa + 1] * bk1[n + 1];
for (int i = (n - 1) / 2 + 2; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
}
private void bluestein_real_inverse2(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] - bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] - bk1[n] * ak[n];
}
}
/*---------------------------------------------------------
rfftf1: further processing of Real forward FFT
--------------------------------------------------------
void rfftf(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, kh, nf, ip, iw, ido, idl1;
final float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 1;
l2 = n;
iw = twon - 1;
for (int k1 = 1; k1 <= nf; ++k1) {
kh = nf - k1;
ip = (int) wtable_r[kh + 2 + twon];
l1 = l2 / ip;
ido = n / l2;
idl1 = ido * l1;
iw -= (ip - 1) * ido;
na = 1 - na;
switch (ip) {
case 2:
if (na == 0) {
radf2(ido, l1, a, offa, ch, 0, iw);
} else {
radf2(ido, l1, ch, 0, a, offa, iw);
}
break;
case 3:
if (na == 0) {
radf3(ido, l1, a, offa, ch, 0, iw);
} else {
radf3(ido, l1, ch, 0, a, offa, iw);
}
break;
case 4:
if (na == 0) {
radf4(ido, l1, a, offa, ch, 0, iw);
} else {
radf4(ido, l1, ch, 0, a, offa, iw);
}
break;
case 5:
if (na == 0) {
radf5(ido, l1, a, offa, ch, 0, iw);
} else {
radf5(ido, l1, ch, 0, a, offa, iw);
}
break;
default:
if (ido == 1)
na = 1 - na;
if (na == 0) {
radfg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
na = 1;
} else {
radfg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
na = 0;
}
break;
}
l2 = l1;
}
if (na == 1)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*---------------------------------------------------------
rfftb1: further processing of Real backward FFT
--------------------------------------------------------
void rfftb(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, nf, ip, iw, ido, idl1;
float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 0;
l1 = 1;
iw = n;
for (int k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
l2 = ip * l1;
ido = n / l2;
idl1 = ido * l1;
switch (ip) {
case 2:
if (na == 0) {
radb2(ido, l1, a, offa, ch, 0, iw);
} else {
radb2(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
radb3(ido, l1, a, offa, ch, 0, iw);
} else {
radb3(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 4:
if (na == 0) {
radb4(ido, l1, a, offa, ch, 0, iw);
} else {
radb4(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
radb5(ido, l1, a, offa, ch, 0, iw);
} else {
radb5(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
default:
if (na == 0) {
radbg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
} else {
radbg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
}
if (ido == 1)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * ido;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*-------------------------------------------------
radf2: Real FFT's forward processing of factor 2
-------------------------------------------------
void radf2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic, idx0, idx1, idx2, idx3, idx4;
float t1i, t1r, w1r, w1i;
int iw1;
iw1 = offset;
idx0 = l1 * ido;
idx1 = 2 * ido;
for (int k = 0; k < l1; k++) {
int oidx1 = out_off + k * idx1;
int oidx2 = oidx1 + idx1 - 1;
int iidx1 = in_off + k * ido;
int iidx2 = iidx1 + idx0;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx2] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
idx2 = 2 * idx1;
idx3 = idx2 + ido;
idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int oidx1 = out_off + i + idx2;
int oidx2 = out_off + ic + idx3;
int iidx1 = in_off + i + idx1;
int iidx2 = in_off + i + idx4;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
t1r = w1r * a2i + w1i * a2r;
t1i = w1r * a2r - w1i * a2i;
out[oidx1] = a1r + t1i;
out[oidx1 - 1] = a1i + t1r;
out[oidx2] = t1i - a1r;
out[oidx2 - 1] = a1i - t1r;
}
}
if (ido % 2 == 1)
return;
}
idx2 = 2 * idx1;
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
int oidx1 = out_off + idx2 + ido;
int iidx1 = in_off + ido - 1 + idx1;
out[oidx1] = -in[iidx1 + idx0];
out[oidx1 - 1] = in[iidx1];
}
}
/*-------------------------------------------------
radb2: Real FFT's backward processing of factor 2
-------------------------------------------------
void radb2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic;
float t1i, t1r, w1r, w1i;
int iw1 = offset;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int oidx1 = out_off + idx1;
int iidx1 = in_off + idx2;
int iidx2 = in_off + ido - 1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx1 + idx0] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx5 = i - 1 + iw1;
int idx6 = out_off + i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
w1r = wtable_r[idx5 - 1];
w1i = wtable_r[idx5];
int iidx1 = idx7 + idx2;
int iidx2 = idx8 + idx3;
int oidx1 = idx6 + idx1;
int oidx2 = idx6 + idx4;
t1r = in[iidx1 - 1] - in[iidx2 - 1];
t1i = in[iidx1] + in[iidx2];
float i1i = in[iidx1];
float i1r = in[iidx1 - 1];
float i2i = in[iidx2];
float i2r = in[iidx2 - 1];
out[oidx1 - 1] = i1r + i2r;
out[oidx1] = i1i - i2i;
out[oidx2 - 1] = w1r * t1r - w1i * t1i;
out[oidx2] = w1r * t1i + w1i * t1r;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int oidx1 = out_off + ido - 1 + idx1;
int iidx1 = in_off + idx2 + ido;
out[oidx1] = 2 * in[iidx1 - 1];
out[oidx1 + idx0] = -2 * in[iidx1];
}
}
/*-------------------------------------------------
radf3: Real FFT's forward processing of factor 3
-------------------------------------------------
void radf3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, di2, di3, cr2, dr2, dr3, ti2, ti3, tr2, tr3, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx3 = 2 * idx0;
int idx4 = (3 * k + 1) * ido;
int iidx1 = in_off + idx1;
int iidx2 = iidx1 + idx0;
int iidx3 = iidx1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
float i3r = in[iidx3];
cr2 = i2r + i3r;
out[out_off + 3 * idx1] = i1r + cr2;
out[out_off + idx4 + ido] = taui * (i3r - i2r);
out[out_off + ido - 1 + idx4] = i1r + taur * cr2;
}
if (ido == 1)
return;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int idx4 = 3 * idx3;
int idx5 = idx3 + idx0;
int idx6 = idx5 + idx0;
int idx7 = idx4 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx3;
int iidx2 = idx9 + idx5;
int iidx3 = idx9 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
cr2 = dr2 + dr3;
ci2 = di2 + di3;
tr2 = i1i + taur * cr2;
ti2 = i1r + taur * ci2;
tr3 = taui * (di2 - di3);
ti3 = taui * (dr3 - dr2);
int oidx1 = idx10 + idx4;
int oidx2 = idx11 + idx7;
int oidx3 = idx10 + idx8;
out[oidx1 - 1] = i1i + cr2;
out[oidx1] = i1r + ci2;
out[oidx2 - 1] = tr2 - tr3;
out[oidx2] = ti3 - ti2;
out[oidx3 - 1] = tr2 + tr3;
out[oidx3] = ti2 + ti3;
}
}
}
/*-------------------------------------------------
radb3: Real FFT's backward processing of factor 3
-------------------------------------------------
void radb3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, ci3, di2, di3, cr2, cr3, dr2, dr3, ti2, tr2, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int iidx1 = in_off + 3 * idx1;
int iidx2 = iidx1 + 2 * ido;
float i1i = in[iidx1];
tr2 = 2 * in[iidx2 - 1];
cr2 = i1i + taur * tr2;
ci3 = 2 * taui * in[iidx2];
out[out_off + idx1] = i1i + tr2;
out[out_off + (k + l1) * ido] = cr2 - ci3;
out[out_off + (k + 2 * l1) * ido] = cr2 + ci3;
}
if (ido == 1)
return;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 3 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx1 + idx0;
int idx6 = idx5 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
int idx9 = out_off + i;
int iidx1 = idx7 + idx2;
int iidx2 = idx7 + idx4;
int iidx3 = idx8 + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
tr2 = i2i + i3i;
cr2 = i1i + taur * tr2;
ti2 = i2r - i3r;
ci2 = i1r + taur * ti2;
cr3 = taui * (i2i - i3i);
ci3 = taui * (i2r + i3r);
dr2 = cr2 - ci3;
dr3 = cr2 + ci3;
di2 = ci2 + cr3;
di3 = ci2 - cr3;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int oidx1 = idx9 + idx1;
int oidx2 = idx9 + idx5;
int oidx3 = idx9 + idx6;
out[oidx1 - 1] = i1i + tr2;
out[oidx1] = i1r + ti2;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
}
}
}
/*-------------------------------------------------
radf4: Real FFT's forward processing of factor 4
-------------------------------------------------
void radf4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float hsqt2 = 0.707106781186547572737310929369414225f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = offset + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx3];
float i3r = in[in_off + idx4];
float i4r = in[in_off + idx5];
tr1 = i2r + i4r;
tr2 = i1r + i3r;
int oidx1 = out_off + idx2;
int oidx2 = out_off + idx6 + ido;
out[oidx1] = tr1 + tr2;
out[oidx2 - 1 + ido + ido] = tr2 - tr1;
out[oidx2 - 1] = i1r - i3r;
out[oidx2] = i4r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx1;
int iidx2 = idx9 + idx2;
int iidx3 = idx9 + idx3;
int iidx4 = idx9 + idx4;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
cr2 = w1r * i2i + w1i * i2r;
ci2 = w1r * i2r - w1i * i2i;
cr3 = w2r * i3i + w2i * i3r;
ci3 = w2r * i3r - w2i * i3i;
cr4 = w3r * i4i + w3i * i4r;
ci4 = w3r * i4r - w3i * i4i;
tr1 = cr2 + cr4;
tr4 = cr4 - cr2;
ti1 = ci2 + ci4;
ti4 = ci2 - ci4;
ti2 = i1r + ci3;
ti3 = i1r - ci3;
tr2 = i1i + cr3;
tr3 = i1i - cr3;
int oidx1 = idx10 + idx5;
int oidx2 = idx11 + idx6;
int oidx3 = idx10 + idx7;
int oidx4 = idx11 + idx8;
out[oidx1 - 1] = tr1 + tr2;
out[oidx4 - 1] = tr2 - tr1;
out[oidx1] = ti1 + ti2;
out[oidx4] = ti1 - ti2;
out[oidx3 - 1] = ti4 + tr3;
out[oidx2 - 1] = tr3 - ti4;
out[oidx3] = tr4 + ti3;
out[oidx2] = tr4 - ti3;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1i = in[idx9 - 1 + idx1];
float i2i = in[idx9 - 1 + idx3];
float i3i = in[idx9 - 1 + idx4];
float i4i = in[idx9 - 1 + idx5];
ti1 = -hsqt2 * (i2i + i4i);
tr1 = hsqt2 * (i2i - i4i);
out[idx10 - 1 + idx2] = tr1 + i1i;
out[idx10 - 1 + idx7] = i1i - tr1;
out[out_off + idx6] = ti1 - i3i;
out[out_off + idx8] = ti1 + i3i;
}
}
/*-------------------------------------------------
radb4: Real FFT's backward processing of factor 4
------------------------------------------------- | FloatFFT::radb4 | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
void radf5(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float tr11 = 0.309016994374947451262869435595348477f;
final float ti11 = 0.951056516295153531181938433292089030f;
final float tr12 = -0.809016994374947340240566973079694435f;
final float ti12 = 0.587785252292473248125759255344746634f;
int i, ic;
float ci2, di2, ci4, ci5, di3, di4, di5, ci3, cr2, cr3, dr2, dr3, dr4, dr5, cr5, cr4, ti2, ti3, ti5, ti4, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
int iw1, iw2, iw3, iw4;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
iw4 = iw3 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
int idx11 = out_off + ido - 1;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx7];
float i3r = in[in_off + idx8];
float i4r = in[in_off + idx9];
float i5r = in[in_off + idx10];
cr2 = i5r + i2r;
ci5 = i5r - i2r;
cr3 = i4r + i3r;
ci4 = i4r - i3r;
out[out_off + idx2] = i1r + cr2 + cr3;
out[idx11 + idx3] = i1r + tr11 * cr2 + tr12 * cr3;
out[out_off + idx4] = ti11 * ci5 + ti12 * ci4;
out[idx11 + idx5] = i1r + tr12 * cr2 + tr11 * cr3;
out[out_off + idx6] = ti12 * ci5 - ti11 * ci4;
}
if (ido == 1)
return;
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
for (i = 2; i < ido; i += 2) {
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
int widx4 = i - 1 + iw4;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
w4r = wtable_r[widx4 - 1];
w4i = wtable_r[widx4];
ic = ido - i;
int idx15 = in_off + i;
int idx16 = out_off + i;
int idx17 = out_off + ic;
int iidx1 = idx15 + idx1;
int iidx2 = idx15 + idx7;
int iidx3 = idx15 + idx8;
int iidx4 = idx15 + idx9;
int iidx5 = idx15 + idx10;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
dr4 = w3r * i4i + w3i * i4r;
di4 = w3r * i4r - w3i * i4i;
dr5 = w4r * i5i + w4i * i5r;
di5 = w4r * i5r - w4i * i5i;
cr2 = dr2 + dr5;
ci5 = dr5 - dr2;
cr5 = di2 - di5;
ci2 = di2 + di5;
cr3 = dr3 + dr4;
ci4 = dr4 - dr3;
cr4 = di3 - di4;
ci3 = di3 + di4;
tr2 = i1i + tr11 * cr2 + tr12 * cr3;
ti2 = i1r + tr11 * ci2 + tr12 * ci3;
tr3 = i1i + tr12 * cr2 + tr11 * cr3;
ti3 = i1r + tr12 * ci2 + tr11 * ci3;
tr5 = ti11 * cr5 + ti12 * cr4;
ti5 = ti11 * ci5 + ti12 * ci4;
tr4 = ti12 * cr5 - ti11 * cr4;
ti4 = ti12 * ci5 - ti11 * ci4;
int oidx1 = idx16 + idx2;
int oidx2 = idx17 + idx3;
int oidx3 = idx16 + idx4;
int oidx4 = idx17 + idx5;
int oidx5 = idx16 + idx6;
out[oidx1 - 1] = i1i + cr2 + cr3;
out[oidx1] = i1r + ci2 + ci3;
out[oidx3 - 1] = tr2 + tr5;
out[oidx2 - 1] = tr2 - tr5;
out[oidx3] = ti2 + ti5;
out[oidx2] = ti5 - ti2;
out[oidx5 - 1] = tr3 + tr4;
out[oidx4 - 1] = tr3 - tr4;
out[oidx5] = ti3 + ti4;
out[oidx4] = ti4 - ti3;
}
}
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. This method computes the full real inverse transform, i.e. you will get
the same result as from <code>complexInverse</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
public void realInverseFull(final float[] a, final int offa, boolean scale) {
final int twon = 2 * n;
switch (plan) {
case SPLIT_RADIX:
realInverse2(a, offa, scale);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n / 2 > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
Future<?>[] futures = new Future[nthreads];
int k = n / 2 / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n / 2 : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
int idx1, idx2;
for (int k = firstIdx; k < lastIdx; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
int idx1, idx2;
for (int k = 0; k < n / 2; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
a[offa + n] = -a[offa + 1];
a[offa + 1] = 0;
break;
case MIXED_RADIX:
rfftf(a, offa);
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
} else {
m = (n + 1) / 2;
}
for (int k = 1; k < m; k++) {
int idx1 = offa + 2 * k;
int idx2 = offa + twon - 2 * k;
a[idx1] = -a[idx1];
a[idx2 + 1] = -a[idx1];
a[idx2] = a[idx1 - 1];
}
for (int k = 1; k < n; k++) {
int idx = offa + n - k;
float tmp = a[idx + 1];
a[idx + 1] = a[idx];
a[idx] = tmp;
}
a[offa + 1] = 0;
break;
case BLUESTEIN:
bluestein_real_full(a, offa, 1);
if (scale) {
scale(n, a, offa, true);
}
break;
}
}
private void realInverse2(float[] a, int offa, boolean scale) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
float xi;
if (n > 4) {
cftfsub(n, a, offa, ip, nw, w);
rftbsub(n, a, offa, nc, w, nw);
} else if (n == 4) {
cftbsub(n, a, offa, ip, nw, w);
}
xi = a[offa] - a[offa + 1];
a[offa] += a[offa + 1];
a[offa + 1] = xi;
if (scale) {
scale(n, a, offa, false);
}
break;
case MIXED_RADIX:
rfftf(a, offa);
for (int k = n - 1; k >= 2; k--) {
int idx = offa + k;
float tmp = a[idx];
a[idx] = a[idx - 1];
a[idx - 1] = tmp;
}
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
for (int i = 1; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
} else {
m = (n - 1) / 2;
for (int i = 0; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
}
break;
case BLUESTEIN:
bluestein_real_inverse2(a, offa);
if (scale) {
scale(n, a, offa, false);
}
break;
}
}
private static int getReminder(int n, int[] factors) {
int reminder = n;
if (n <= 0) {
throw new IllegalArgumentException("n must be positive integer");
}
for (int i = 0; i < factors.length && reminder != 1; i++) {
int factor = factors[i];
while ((reminder % factor) == 0) {
reminder /= factor;
}
}
return reminder;
}
/* -------- initializing routines --------
/*---------------------------------------------------------
cffti: initialization of Complex FFT
--------------------------------------------------------
void cffti(int n, int offw) {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[offw + nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[offw + idx + 1] = wtable[offw + idx];
}
wtable[offw + 2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[offw + fourn] = n;
wtable[offw + 1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[offw + k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[offw + i - 1 + twon] = 1;
wtable[offw + i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[offw + idx - 1] = (float)Math.cos(arg);
wtable[offw + idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[offw + idx1 - 1] = wtable[offw + idx2 - 1];
wtable[offw + idx1] = wtable[offw + idx2];
}
}
l1 = l2;
}
}
void cffti() {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[idx + 1] = wtable[idx];
}
wtable[2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[fourn] = n;
wtable[1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[i - 1 + twon] = 1;
wtable[i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[idx - 1] = (float)Math.cos(arg);
wtable[idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[idx1 - 1] = wtable[idx2 - 1];
wtable[idx1] = wtable[idx2];
}
}
l1 = l2;
}
}
void rffti() {
if (n == 1)
return;
final int twon = 2 * n;
float argh;
int ntry = 0, i, j;
float argld;
int k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, is, nq, nr;
float arg;
int ido, ipm;
int nfm1;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
++j;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
++nf;
wtable_r[nf + 1 + twon] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + twon;
wtable_r[idx + 1] = wtable_r[idx];
}
wtable_r[2 + twon] = 2;
}
} while (nl != 1);
break;
}
wtable_r[twon] = n;
wtable_r[1 + twon] = nf;
argh = TWO_PI / (float) (n);
is = 0;
nfm1 = nf - 1;
l1 = 1;
if (nfm1 == 0)
return;
for (k1 = 1; k1 <= nfm1; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
ipm = ip - 1;
for (j = 1; j <= ipm; ++j) {
ld += l1;
i = is;
argld = (float) ld * argh;
fi = 0;
for (ii = 3; ii <= ido; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + n;
wtable_r[idx - 2] = (float)Math.cos(arg);
wtable_r[idx - 1] = (float)Math.sin(arg);
}
is += ido;
}
l1 = l2;
}
}
private void bluesteini() {
int k = 0;
float arg;
float pi_n = PI / n;
bk1[0] = 1;
bk1[1] = 0;
for (int i = 1; i < n; i++) {
k += 2 * i - 1;
if (k >= 2 * n)
k -= 2 * n;
arg = pi_n * k;
bk1[2 * i] = (float)Math.cos(arg);
bk1[2 * i + 1] = (float)Math.sin(arg);
}
float scale = (float)(1.0 / nBluestein);
bk2[0] = bk1[0] * scale;
bk2[1] = bk1[1] * scale;
for (int i = 2; i < 2 * n; i += 2) {
bk2[i] = bk1[i] * scale;
bk2[i + 1] = bk1[i + 1] * scale;
bk2[2 * nBluestein - i] = bk2[i];
bk2[2 * nBluestein - i + 1] = bk2[i + 1];
}
cftbsub(2 * nBluestein, bk2, 0, ip, nw, w);
}
private void makewt(int nw) {
int j, nwh, nw0, nw1;
float delta, wn4r, wk1r, wk1i, wk3r, wk3i;
float delta2, deltaj, deltaj3;
ip[0] = nw;
ip[1] = 1;
if (nw > 2) {
nwh = nw >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nwh);
delta2 = delta * 2;
wn4r = (float)Math.cos(delta * nwh);
w[0] = 1;
w[1] = wn4r;
if (nwh == 4) {
w[2] = (float)Math.cos(delta2);
w[3] = (float)Math.sin(delta2);
} else if (nwh > 4) {
makeipt(nw);
w[2] = (float)(0.5 / Math.cos(delta2));
w[3] = (float)(0.5 / Math.cos(delta * 6));
for (j = 4; j < nwh; j += 4) {
deltaj = delta * j;
deltaj3 = 3 * deltaj;
w[j] = (float)Math.cos(deltaj);
w[j + 1] = (float)Math.sin(deltaj);
w[j + 2] = (float)Math.cos(deltaj3);
w[j + 3] = (float)-Math.sin(deltaj3);
}
}
nw0 = 0;
while (nwh > 2) {
nw1 = nw0 + nwh;
nwh >>= 1;
w[nw1] = 1;
w[nw1 + 1] = wn4r;
if (nwh == 4) {
wk1r = w[nw0 + 4];
wk1i = w[nw0 + 5];
w[nw1 + 2] = wk1r;
w[nw1 + 3] = wk1i;
} else if (nwh > 4) {
wk1r = w[nw0 + 4];
wk3r = w[nw0 + 6];
w[nw1 + 2] = (float)(0.5 / wk1r);
w[nw1 + 3] = (float)(0.5 / wk3r);
for (j = 4; j < nwh; j += 4) {
int idx1 = nw0 + 2 * j;
int idx2 = nw1 + j;
wk1r = w[idx1];
wk1i = w[idx1 + 1];
wk3r = w[idx1 + 2];
wk3i = w[idx1 + 3];
w[idx2] = wk1r;
w[idx2 + 1] = wk1i;
w[idx2 + 2] = wk3r;
w[idx2 + 3] = wk3i;
}
}
nw0 = nw1;
}
}
}
private void makeipt(int nw) {
int j, l, m, m2, p, q;
ip[2] = 0;
ip[3] = 16;
m = 2;
for (l = nw; l > 32; l >>= 2) {
m2 = m << 1;
q = m2 << 3;
for (j = m; j < m2; j++) {
p = ip[j] << 2;
ip[m + j] = p;
ip[m2 + j] = p + q;
}
m = m2;
}
}
private void makect(int nc, float[] c, int startc) {
int j, nch;
float delta, deltaj;
ip[1] = nc;
if (nc > 1) {
nch = nc >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nch);
c[startc] = (float)Math.cos(delta * nch);
c[startc + nch] = (float)(0.5 * c[startc]);
for (j = 1; j < nch; j++) {
deltaj = delta * j;
c[startc + j] = (float)(0.5 * Math.cos(deltaj));
c[startc + nc - j] = (float)(0.5 * Math.sin(deltaj));
}
}
}
private void bluestein_complex(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_full(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_forward(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] + bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = -bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] + bk1[n] * ak[n];
}
}
private void bluestein_real_inverse(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
if (n % 2 == 0) {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n] = a[offa + 1] * bk1[n];
ak[n + 1] = a[offa + 1] * bk1[n + 1];
for (int i = n / 2 + 1; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
} else {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n - 1] = a[offa + n - 1] * bk1[n - 1] - a[offa + 1] * bk1[n];
ak[n] = a[offa + n - 1] * bk1[n] + a[offa + 1] * bk1[n - 1];
ak[n + 1] = a[offa + n - 1] * bk1[n + 1] + a[offa + 1] * bk1[n + 2];
ak[n + 2] = a[offa + n - 1] * bk1[n + 2] - a[offa + 1] * bk1[n + 1];
for (int i = (n - 1) / 2 + 2; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
}
private void bluestein_real_inverse2(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] - bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] - bk1[n] * ak[n];
}
}
/*---------------------------------------------------------
rfftf1: further processing of Real forward FFT
--------------------------------------------------------
void rfftf(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, kh, nf, ip, iw, ido, idl1;
final float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 1;
l2 = n;
iw = twon - 1;
for (int k1 = 1; k1 <= nf; ++k1) {
kh = nf - k1;
ip = (int) wtable_r[kh + 2 + twon];
l1 = l2 / ip;
ido = n / l2;
idl1 = ido * l1;
iw -= (ip - 1) * ido;
na = 1 - na;
switch (ip) {
case 2:
if (na == 0) {
radf2(ido, l1, a, offa, ch, 0, iw);
} else {
radf2(ido, l1, ch, 0, a, offa, iw);
}
break;
case 3:
if (na == 0) {
radf3(ido, l1, a, offa, ch, 0, iw);
} else {
radf3(ido, l1, ch, 0, a, offa, iw);
}
break;
case 4:
if (na == 0) {
radf4(ido, l1, a, offa, ch, 0, iw);
} else {
radf4(ido, l1, ch, 0, a, offa, iw);
}
break;
case 5:
if (na == 0) {
radf5(ido, l1, a, offa, ch, 0, iw);
} else {
radf5(ido, l1, ch, 0, a, offa, iw);
}
break;
default:
if (ido == 1)
na = 1 - na;
if (na == 0) {
radfg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
na = 1;
} else {
radfg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
na = 0;
}
break;
}
l2 = l1;
}
if (na == 1)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*---------------------------------------------------------
rfftb1: further processing of Real backward FFT
--------------------------------------------------------
void rfftb(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, nf, ip, iw, ido, idl1;
float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 0;
l1 = 1;
iw = n;
for (int k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
l2 = ip * l1;
ido = n / l2;
idl1 = ido * l1;
switch (ip) {
case 2:
if (na == 0) {
radb2(ido, l1, a, offa, ch, 0, iw);
} else {
radb2(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
radb3(ido, l1, a, offa, ch, 0, iw);
} else {
radb3(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 4:
if (na == 0) {
radb4(ido, l1, a, offa, ch, 0, iw);
} else {
radb4(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
radb5(ido, l1, a, offa, ch, 0, iw);
} else {
radb5(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
default:
if (na == 0) {
radbg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
} else {
radbg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
}
if (ido == 1)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * ido;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*-------------------------------------------------
radf2: Real FFT's forward processing of factor 2
-------------------------------------------------
void radf2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic, idx0, idx1, idx2, idx3, idx4;
float t1i, t1r, w1r, w1i;
int iw1;
iw1 = offset;
idx0 = l1 * ido;
idx1 = 2 * ido;
for (int k = 0; k < l1; k++) {
int oidx1 = out_off + k * idx1;
int oidx2 = oidx1 + idx1 - 1;
int iidx1 = in_off + k * ido;
int iidx2 = iidx1 + idx0;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx2] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
idx2 = 2 * idx1;
idx3 = idx2 + ido;
idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int oidx1 = out_off + i + idx2;
int oidx2 = out_off + ic + idx3;
int iidx1 = in_off + i + idx1;
int iidx2 = in_off + i + idx4;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
t1r = w1r * a2i + w1i * a2r;
t1i = w1r * a2r - w1i * a2i;
out[oidx1] = a1r + t1i;
out[oidx1 - 1] = a1i + t1r;
out[oidx2] = t1i - a1r;
out[oidx2 - 1] = a1i - t1r;
}
}
if (ido % 2 == 1)
return;
}
idx2 = 2 * idx1;
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
int oidx1 = out_off + idx2 + ido;
int iidx1 = in_off + ido - 1 + idx1;
out[oidx1] = -in[iidx1 + idx0];
out[oidx1 - 1] = in[iidx1];
}
}
/*-------------------------------------------------
radb2: Real FFT's backward processing of factor 2
-------------------------------------------------
void radb2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic;
float t1i, t1r, w1r, w1i;
int iw1 = offset;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int oidx1 = out_off + idx1;
int iidx1 = in_off + idx2;
int iidx2 = in_off + ido - 1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx1 + idx0] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx5 = i - 1 + iw1;
int idx6 = out_off + i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
w1r = wtable_r[idx5 - 1];
w1i = wtable_r[idx5];
int iidx1 = idx7 + idx2;
int iidx2 = idx8 + idx3;
int oidx1 = idx6 + idx1;
int oidx2 = idx6 + idx4;
t1r = in[iidx1 - 1] - in[iidx2 - 1];
t1i = in[iidx1] + in[iidx2];
float i1i = in[iidx1];
float i1r = in[iidx1 - 1];
float i2i = in[iidx2];
float i2r = in[iidx2 - 1];
out[oidx1 - 1] = i1r + i2r;
out[oidx1] = i1i - i2i;
out[oidx2 - 1] = w1r * t1r - w1i * t1i;
out[oidx2] = w1r * t1i + w1i * t1r;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int oidx1 = out_off + ido - 1 + idx1;
int iidx1 = in_off + idx2 + ido;
out[oidx1] = 2 * in[iidx1 - 1];
out[oidx1 + idx0] = -2 * in[iidx1];
}
}
/*-------------------------------------------------
radf3: Real FFT's forward processing of factor 3
-------------------------------------------------
void radf3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, di2, di3, cr2, dr2, dr3, ti2, ti3, tr2, tr3, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx3 = 2 * idx0;
int idx4 = (3 * k + 1) * ido;
int iidx1 = in_off + idx1;
int iidx2 = iidx1 + idx0;
int iidx3 = iidx1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
float i3r = in[iidx3];
cr2 = i2r + i3r;
out[out_off + 3 * idx1] = i1r + cr2;
out[out_off + idx4 + ido] = taui * (i3r - i2r);
out[out_off + ido - 1 + idx4] = i1r + taur * cr2;
}
if (ido == 1)
return;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int idx4 = 3 * idx3;
int idx5 = idx3 + idx0;
int idx6 = idx5 + idx0;
int idx7 = idx4 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx3;
int iidx2 = idx9 + idx5;
int iidx3 = idx9 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
cr2 = dr2 + dr3;
ci2 = di2 + di3;
tr2 = i1i + taur * cr2;
ti2 = i1r + taur * ci2;
tr3 = taui * (di2 - di3);
ti3 = taui * (dr3 - dr2);
int oidx1 = idx10 + idx4;
int oidx2 = idx11 + idx7;
int oidx3 = idx10 + idx8;
out[oidx1 - 1] = i1i + cr2;
out[oidx1] = i1r + ci2;
out[oidx2 - 1] = tr2 - tr3;
out[oidx2] = ti3 - ti2;
out[oidx3 - 1] = tr2 + tr3;
out[oidx3] = ti2 + ti3;
}
}
}
/*-------------------------------------------------
radb3: Real FFT's backward processing of factor 3
-------------------------------------------------
void radb3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, ci3, di2, di3, cr2, cr3, dr2, dr3, ti2, tr2, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int iidx1 = in_off + 3 * idx1;
int iidx2 = iidx1 + 2 * ido;
float i1i = in[iidx1];
tr2 = 2 * in[iidx2 - 1];
cr2 = i1i + taur * tr2;
ci3 = 2 * taui * in[iidx2];
out[out_off + idx1] = i1i + tr2;
out[out_off + (k + l1) * ido] = cr2 - ci3;
out[out_off + (k + 2 * l1) * ido] = cr2 + ci3;
}
if (ido == 1)
return;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 3 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx1 + idx0;
int idx6 = idx5 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
int idx9 = out_off + i;
int iidx1 = idx7 + idx2;
int iidx2 = idx7 + idx4;
int iidx3 = idx8 + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
tr2 = i2i + i3i;
cr2 = i1i + taur * tr2;
ti2 = i2r - i3r;
ci2 = i1r + taur * ti2;
cr3 = taui * (i2i - i3i);
ci3 = taui * (i2r + i3r);
dr2 = cr2 - ci3;
dr3 = cr2 + ci3;
di2 = ci2 + cr3;
di3 = ci2 - cr3;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int oidx1 = idx9 + idx1;
int oidx2 = idx9 + idx5;
int oidx3 = idx9 + idx6;
out[oidx1 - 1] = i1i + tr2;
out[oidx1] = i1r + ti2;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
}
}
}
/*-------------------------------------------------
radf4: Real FFT's forward processing of factor 4
-------------------------------------------------
void radf4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float hsqt2 = 0.707106781186547572737310929369414225f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = offset + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx3];
float i3r = in[in_off + idx4];
float i4r = in[in_off + idx5];
tr1 = i2r + i4r;
tr2 = i1r + i3r;
int oidx1 = out_off + idx2;
int oidx2 = out_off + idx6 + ido;
out[oidx1] = tr1 + tr2;
out[oidx2 - 1 + ido + ido] = tr2 - tr1;
out[oidx2 - 1] = i1r - i3r;
out[oidx2] = i4r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx1;
int iidx2 = idx9 + idx2;
int iidx3 = idx9 + idx3;
int iidx4 = idx9 + idx4;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
cr2 = w1r * i2i + w1i * i2r;
ci2 = w1r * i2r - w1i * i2i;
cr3 = w2r * i3i + w2i * i3r;
ci3 = w2r * i3r - w2i * i3i;
cr4 = w3r * i4i + w3i * i4r;
ci4 = w3r * i4r - w3i * i4i;
tr1 = cr2 + cr4;
tr4 = cr4 - cr2;
ti1 = ci2 + ci4;
ti4 = ci2 - ci4;
ti2 = i1r + ci3;
ti3 = i1r - ci3;
tr2 = i1i + cr3;
tr3 = i1i - cr3;
int oidx1 = idx10 + idx5;
int oidx2 = idx11 + idx6;
int oidx3 = idx10 + idx7;
int oidx4 = idx11 + idx8;
out[oidx1 - 1] = tr1 + tr2;
out[oidx4 - 1] = tr2 - tr1;
out[oidx1] = ti1 + ti2;
out[oidx4] = ti1 - ti2;
out[oidx3 - 1] = ti4 + tr3;
out[oidx2 - 1] = tr3 - ti4;
out[oidx3] = tr4 + ti3;
out[oidx2] = tr4 - ti3;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1i = in[idx9 - 1 + idx1];
float i2i = in[idx9 - 1 + idx3];
float i3i = in[idx9 - 1 + idx4];
float i4i = in[idx9 - 1 + idx5];
ti1 = -hsqt2 * (i2i + i4i);
tr1 = hsqt2 * (i2i - i4i);
out[idx10 - 1 + idx2] = tr1 + i1i;
out[idx10 - 1 + idx7] = i1i - tr1;
out[out_off + idx6] = ti1 - i3i;
out[out_off + idx8] = ti1 + i3i;
}
}
/*-------------------------------------------------
radb4: Real FFT's backward processing of factor 4
-------------------------------------------------
void radb4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float sqrt2 = 1.41421356237309514547462185873882845f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4;
float ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
float i1r = in[in_off + idx2];
float i2r = in[in_off + idx7];
float i3r = in[in_off + ido - 1 + idx8];
float i4r = in[in_off + ido - 1 + idx6];
tr1 = i1r - i3r;
tr2 = i1r + i3r;
tr3 = i4r + i4r;
tr4 = i2r + i2r;
out[out_off + idx1] = tr2 + tr3;
out[out_off + idx3] = tr1 - tr4;
out[out_off + idx4] = tr2 - tr3;
out[out_off + idx5] = tr1 + tr4;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx12 = in_off + i;
int idx13 = in_off + ic;
int idx14 = out_off + i;
int iidx1 = idx12 + idx5;
int iidx2 = idx13 + idx6;
int iidx3 = idx12 + idx7;
int iidx4 = idx13 + idx8;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
ti1 = i1r + i4r;
ti2 = i1r - i4r;
ti3 = i3r - i2r;
tr4 = i3r + i2r;
tr1 = i1i - i4i;
tr2 = i1i + i4i;
ti4 = i3i - i2i;
tr3 = i3i + i2i;
cr3 = tr2 - tr3;
ci3 = ti2 - ti3;
cr2 = tr1 - tr4;
cr4 = tr1 + tr4;
ci2 = ti1 + ti4;
ci4 = ti1 - ti4;
int oidx1 = idx14 + idx1;
int oidx2 = idx14 + idx2;
int oidx3 = idx14 + idx3;
int oidx4 = idx14 + idx4;
out[oidx1 - 1] = tr2 + tr3;
out[oidx1] = ti2 + ti3;
out[oidx2 - 1] = w1r * cr2 - w1i * ci2;
out[oidx2] = w1r * ci2 + w1i * cr2;
out[oidx3 - 1] = w2r * cr3 - w2i * ci3;
out[oidx3] = w2r * ci3 + w2i * cr3;
out[oidx4 - 1] = w3r * cr4 - w3i * ci4;
out[oidx4] = w3r * ci4 + w3i * cr4;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1r = in[idx9 - 1 + idx2];
float i2r = in[idx9 - 1 + idx7];
float i3r = in[in_off + idx6];
float i4r = in[in_off + idx8];
ti1 = i3r + i4r;
ti2 = i4r - i3r;
tr1 = i1r - i2r;
tr2 = i1r + i2r;
out[idx10 - 1 + idx1] = tr2 + tr2;
out[idx10 - 1 + idx3] = sqrt2 * (tr1 - ti1);
out[idx10 - 1 + idx4] = ti2 + ti2;
out[idx10 - 1 + idx5] = -sqrt2 * (tr1 + ti1);
}
}
/*-------------------------------------------------
radf5: Real FFT's forward processing of factor 5
------------------------------------------------- | FloatFFT::radf5 | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
void radb5(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float tr11 = 0.309016994374947451262869435595348477f;
final float ti11 = 0.951056516295153531181938433292089030f;
final float tr12 = -0.809016994374947340240566973079694435f;
final float ti12 = 0.587785252292473248125759255344746634f;
int i, ic;
float ci2, ci3, ci4, ci5, di3, di4, di5, di2, cr2, cr3, cr5, cr4, ti2, ti3, ti4, ti5, dr3, dr4, dr5, dr2, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
int iw1, iw2, iw3, iw4;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
iw4 = iw3 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
int idx11 = in_off + ido - 1;
float i1r = in[in_off + idx2];
ti5 = 2 * in[in_off + idx4];
ti4 = 2 * in[in_off + idx6];
tr2 = 2 * in[idx11 + idx3];
tr3 = 2 * in[idx11 + idx5];
cr2 = i1r + tr11 * tr2 + tr12 * tr3;
cr3 = i1r + tr12 * tr2 + tr11 * tr3;
ci5 = ti11 * ti5 + ti12 * ti4;
ci4 = ti12 * ti5 - ti11 * ti4;
out[out_off + idx1] = i1r + tr2 + tr3;
out[out_off + idx7] = cr2 - ci5;
out[out_off + idx8] = cr3 - ci4;
out[out_off + idx9] = cr3 + ci4;
out[out_off + idx10] = cr2 + ci5;
}
if (ido == 1)
return;
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
int widx4 = i - 1 + iw4;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
w4r = wtable_r[widx4 - 1];
w4i = wtable_r[widx4];
int idx15 = in_off + i;
int idx16 = in_off + ic;
int idx17 = out_off + i;
int iidx1 = idx15 + idx2;
int iidx2 = idx16 + idx3;
int iidx3 = idx15 + idx4;
int iidx4 = idx16 + idx5;
int iidx5 = idx15 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
ti5 = i3r + i2r;
ti2 = i3r - i2r;
ti4 = i5r + i4r;
ti3 = i5r - i4r;
tr5 = i3i - i2i;
tr2 = i3i + i2i;
tr4 = i5i - i4i;
tr3 = i5i + i4i;
cr2 = i1i + tr11 * tr2 + tr12 * tr3;
ci2 = i1r + tr11 * ti2 + tr12 * ti3;
cr3 = i1i + tr12 * tr2 + tr11 * tr3;
ci3 = i1r + tr12 * ti2 + tr11 * ti3;
cr5 = ti11 * tr5 + ti12 * tr4;
ci5 = ti11 * ti5 + ti12 * ti4;
cr4 = ti12 * tr5 - ti11 * tr4;
ci4 = ti12 * ti5 - ti11 * ti4;
dr3 = cr3 - ci4;
dr4 = cr3 + ci4;
di3 = ci3 + cr4;
di4 = ci3 - cr4;
dr5 = cr2 + ci5;
dr2 = cr2 - ci5;
di5 = ci2 - cr5;
di2 = ci2 + cr5;
int oidx1 = idx17 + idx1;
int oidx2 = idx17 + idx7;
int oidx3 = idx17 + idx8;
int oidx4 = idx17 + idx9;
int oidx5 = idx17 + idx10;
out[oidx1 - 1] = i1i + tr2 + tr3;
out[oidx1] = i1r + ti2 + ti3;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
out[oidx4 - 1] = w3r * dr4 - w3i * di4;
out[oidx4] = w3r * di4 + w3i * dr4;
out[oidx5 - 1] = w4r * dr5 - w4i * di5;
out[oidx5] = w4r * di5 + w4i * dr5;
}
}
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. This method computes the full real inverse transform, i.e. you will get
the same result as from <code>complexInverse</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
public void realInverseFull(final float[] a, final int offa, boolean scale) {
final int twon = 2 * n;
switch (plan) {
case SPLIT_RADIX:
realInverse2(a, offa, scale);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n / 2 > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
Future<?>[] futures = new Future[nthreads];
int k = n / 2 / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n / 2 : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
int idx1, idx2;
for (int k = firstIdx; k < lastIdx; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
int idx1, idx2;
for (int k = 0; k < n / 2; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
a[offa + n] = -a[offa + 1];
a[offa + 1] = 0;
break;
case MIXED_RADIX:
rfftf(a, offa);
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
} else {
m = (n + 1) / 2;
}
for (int k = 1; k < m; k++) {
int idx1 = offa + 2 * k;
int idx2 = offa + twon - 2 * k;
a[idx1] = -a[idx1];
a[idx2 + 1] = -a[idx1];
a[idx2] = a[idx1 - 1];
}
for (int k = 1; k < n; k++) {
int idx = offa + n - k;
float tmp = a[idx + 1];
a[idx + 1] = a[idx];
a[idx] = tmp;
}
a[offa + 1] = 0;
break;
case BLUESTEIN:
bluestein_real_full(a, offa, 1);
if (scale) {
scale(n, a, offa, true);
}
break;
}
}
private void realInverse2(float[] a, int offa, boolean scale) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
float xi;
if (n > 4) {
cftfsub(n, a, offa, ip, nw, w);
rftbsub(n, a, offa, nc, w, nw);
} else if (n == 4) {
cftbsub(n, a, offa, ip, nw, w);
}
xi = a[offa] - a[offa + 1];
a[offa] += a[offa + 1];
a[offa + 1] = xi;
if (scale) {
scale(n, a, offa, false);
}
break;
case MIXED_RADIX:
rfftf(a, offa);
for (int k = n - 1; k >= 2; k--) {
int idx = offa + k;
float tmp = a[idx];
a[idx] = a[idx - 1];
a[idx - 1] = tmp;
}
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
for (int i = 1; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
} else {
m = (n - 1) / 2;
for (int i = 0; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
}
break;
case BLUESTEIN:
bluestein_real_inverse2(a, offa);
if (scale) {
scale(n, a, offa, false);
}
break;
}
}
private static int getReminder(int n, int[] factors) {
int reminder = n;
if (n <= 0) {
throw new IllegalArgumentException("n must be positive integer");
}
for (int i = 0; i < factors.length && reminder != 1; i++) {
int factor = factors[i];
while ((reminder % factor) == 0) {
reminder /= factor;
}
}
return reminder;
}
/* -------- initializing routines --------
/*---------------------------------------------------------
cffti: initialization of Complex FFT
--------------------------------------------------------
void cffti(int n, int offw) {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[offw + nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[offw + idx + 1] = wtable[offw + idx];
}
wtable[offw + 2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[offw + fourn] = n;
wtable[offw + 1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[offw + k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[offw + i - 1 + twon] = 1;
wtable[offw + i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[offw + idx - 1] = (float)Math.cos(arg);
wtable[offw + idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[offw + idx1 - 1] = wtable[offw + idx2 - 1];
wtable[offw + idx1] = wtable[offw + idx2];
}
}
l1 = l2;
}
}
void cffti() {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[idx + 1] = wtable[idx];
}
wtable[2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[fourn] = n;
wtable[1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[i - 1 + twon] = 1;
wtable[i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[idx - 1] = (float)Math.cos(arg);
wtable[idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[idx1 - 1] = wtable[idx2 - 1];
wtable[idx1] = wtable[idx2];
}
}
l1 = l2;
}
}
void rffti() {
if (n == 1)
return;
final int twon = 2 * n;
float argh;
int ntry = 0, i, j;
float argld;
int k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, is, nq, nr;
float arg;
int ido, ipm;
int nfm1;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
++j;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
++nf;
wtable_r[nf + 1 + twon] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + twon;
wtable_r[idx + 1] = wtable_r[idx];
}
wtable_r[2 + twon] = 2;
}
} while (nl != 1);
break;
}
wtable_r[twon] = n;
wtable_r[1 + twon] = nf;
argh = TWO_PI / (float) (n);
is = 0;
nfm1 = nf - 1;
l1 = 1;
if (nfm1 == 0)
return;
for (k1 = 1; k1 <= nfm1; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
ipm = ip - 1;
for (j = 1; j <= ipm; ++j) {
ld += l1;
i = is;
argld = (float) ld * argh;
fi = 0;
for (ii = 3; ii <= ido; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + n;
wtable_r[idx - 2] = (float)Math.cos(arg);
wtable_r[idx - 1] = (float)Math.sin(arg);
}
is += ido;
}
l1 = l2;
}
}
private void bluesteini() {
int k = 0;
float arg;
float pi_n = PI / n;
bk1[0] = 1;
bk1[1] = 0;
for (int i = 1; i < n; i++) {
k += 2 * i - 1;
if (k >= 2 * n)
k -= 2 * n;
arg = pi_n * k;
bk1[2 * i] = (float)Math.cos(arg);
bk1[2 * i + 1] = (float)Math.sin(arg);
}
float scale = (float)(1.0 / nBluestein);
bk2[0] = bk1[0] * scale;
bk2[1] = bk1[1] * scale;
for (int i = 2; i < 2 * n; i += 2) {
bk2[i] = bk1[i] * scale;
bk2[i + 1] = bk1[i + 1] * scale;
bk2[2 * nBluestein - i] = bk2[i];
bk2[2 * nBluestein - i + 1] = bk2[i + 1];
}
cftbsub(2 * nBluestein, bk2, 0, ip, nw, w);
}
private void makewt(int nw) {
int j, nwh, nw0, nw1;
float delta, wn4r, wk1r, wk1i, wk3r, wk3i;
float delta2, deltaj, deltaj3;
ip[0] = nw;
ip[1] = 1;
if (nw > 2) {
nwh = nw >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nwh);
delta2 = delta * 2;
wn4r = (float)Math.cos(delta * nwh);
w[0] = 1;
w[1] = wn4r;
if (nwh == 4) {
w[2] = (float)Math.cos(delta2);
w[3] = (float)Math.sin(delta2);
} else if (nwh > 4) {
makeipt(nw);
w[2] = (float)(0.5 / Math.cos(delta2));
w[3] = (float)(0.5 / Math.cos(delta * 6));
for (j = 4; j < nwh; j += 4) {
deltaj = delta * j;
deltaj3 = 3 * deltaj;
w[j] = (float)Math.cos(deltaj);
w[j + 1] = (float)Math.sin(deltaj);
w[j + 2] = (float)Math.cos(deltaj3);
w[j + 3] = (float)-Math.sin(deltaj3);
}
}
nw0 = 0;
while (nwh > 2) {
nw1 = nw0 + nwh;
nwh >>= 1;
w[nw1] = 1;
w[nw1 + 1] = wn4r;
if (nwh == 4) {
wk1r = w[nw0 + 4];
wk1i = w[nw0 + 5];
w[nw1 + 2] = wk1r;
w[nw1 + 3] = wk1i;
} else if (nwh > 4) {
wk1r = w[nw0 + 4];
wk3r = w[nw0 + 6];
w[nw1 + 2] = (float)(0.5 / wk1r);
w[nw1 + 3] = (float)(0.5 / wk3r);
for (j = 4; j < nwh; j += 4) {
int idx1 = nw0 + 2 * j;
int idx2 = nw1 + j;
wk1r = w[idx1];
wk1i = w[idx1 + 1];
wk3r = w[idx1 + 2];
wk3i = w[idx1 + 3];
w[idx2] = wk1r;
w[idx2 + 1] = wk1i;
w[idx2 + 2] = wk3r;
w[idx2 + 3] = wk3i;
}
}
nw0 = nw1;
}
}
}
private void makeipt(int nw) {
int j, l, m, m2, p, q;
ip[2] = 0;
ip[3] = 16;
m = 2;
for (l = nw; l > 32; l >>= 2) {
m2 = m << 1;
q = m2 << 3;
for (j = m; j < m2; j++) {
p = ip[j] << 2;
ip[m + j] = p;
ip[m2 + j] = p + q;
}
m = m2;
}
}
private void makect(int nc, float[] c, int startc) {
int j, nch;
float delta, deltaj;
ip[1] = nc;
if (nc > 1) {
nch = nc >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nch);
c[startc] = (float)Math.cos(delta * nch);
c[startc + nch] = (float)(0.5 * c[startc]);
for (j = 1; j < nch; j++) {
deltaj = delta * j;
c[startc + j] = (float)(0.5 * Math.cos(deltaj));
c[startc + nc - j] = (float)(0.5 * Math.sin(deltaj));
}
}
}
private void bluestein_complex(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_full(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_forward(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] + bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = -bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] + bk1[n] * ak[n];
}
}
private void bluestein_real_inverse(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
if (n % 2 == 0) {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n] = a[offa + 1] * bk1[n];
ak[n + 1] = a[offa + 1] * bk1[n + 1];
for (int i = n / 2 + 1; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
} else {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n - 1] = a[offa + n - 1] * bk1[n - 1] - a[offa + 1] * bk1[n];
ak[n] = a[offa + n - 1] * bk1[n] + a[offa + 1] * bk1[n - 1];
ak[n + 1] = a[offa + n - 1] * bk1[n + 1] + a[offa + 1] * bk1[n + 2];
ak[n + 2] = a[offa + n - 1] * bk1[n + 2] - a[offa + 1] * bk1[n + 1];
for (int i = (n - 1) / 2 + 2; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
}
private void bluestein_real_inverse2(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] - bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] - bk1[n] * ak[n];
}
}
/*---------------------------------------------------------
rfftf1: further processing of Real forward FFT
--------------------------------------------------------
void rfftf(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, kh, nf, ip, iw, ido, idl1;
final float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 1;
l2 = n;
iw = twon - 1;
for (int k1 = 1; k1 <= nf; ++k1) {
kh = nf - k1;
ip = (int) wtable_r[kh + 2 + twon];
l1 = l2 / ip;
ido = n / l2;
idl1 = ido * l1;
iw -= (ip - 1) * ido;
na = 1 - na;
switch (ip) {
case 2:
if (na == 0) {
radf2(ido, l1, a, offa, ch, 0, iw);
} else {
radf2(ido, l1, ch, 0, a, offa, iw);
}
break;
case 3:
if (na == 0) {
radf3(ido, l1, a, offa, ch, 0, iw);
} else {
radf3(ido, l1, ch, 0, a, offa, iw);
}
break;
case 4:
if (na == 0) {
radf4(ido, l1, a, offa, ch, 0, iw);
} else {
radf4(ido, l1, ch, 0, a, offa, iw);
}
break;
case 5:
if (na == 0) {
radf5(ido, l1, a, offa, ch, 0, iw);
} else {
radf5(ido, l1, ch, 0, a, offa, iw);
}
break;
default:
if (ido == 1)
na = 1 - na;
if (na == 0) {
radfg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
na = 1;
} else {
radfg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
na = 0;
}
break;
}
l2 = l1;
}
if (na == 1)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*---------------------------------------------------------
rfftb1: further processing of Real backward FFT
--------------------------------------------------------
void rfftb(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, nf, ip, iw, ido, idl1;
float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 0;
l1 = 1;
iw = n;
for (int k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
l2 = ip * l1;
ido = n / l2;
idl1 = ido * l1;
switch (ip) {
case 2:
if (na == 0) {
radb2(ido, l1, a, offa, ch, 0, iw);
} else {
radb2(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
radb3(ido, l1, a, offa, ch, 0, iw);
} else {
radb3(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 4:
if (na == 0) {
radb4(ido, l1, a, offa, ch, 0, iw);
} else {
radb4(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
radb5(ido, l1, a, offa, ch, 0, iw);
} else {
radb5(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
default:
if (na == 0) {
radbg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
} else {
radbg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
}
if (ido == 1)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * ido;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*-------------------------------------------------
radf2: Real FFT's forward processing of factor 2
-------------------------------------------------
void radf2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic, idx0, idx1, idx2, idx3, idx4;
float t1i, t1r, w1r, w1i;
int iw1;
iw1 = offset;
idx0 = l1 * ido;
idx1 = 2 * ido;
for (int k = 0; k < l1; k++) {
int oidx1 = out_off + k * idx1;
int oidx2 = oidx1 + idx1 - 1;
int iidx1 = in_off + k * ido;
int iidx2 = iidx1 + idx0;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx2] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
idx2 = 2 * idx1;
idx3 = idx2 + ido;
idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int oidx1 = out_off + i + idx2;
int oidx2 = out_off + ic + idx3;
int iidx1 = in_off + i + idx1;
int iidx2 = in_off + i + idx4;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
t1r = w1r * a2i + w1i * a2r;
t1i = w1r * a2r - w1i * a2i;
out[oidx1] = a1r + t1i;
out[oidx1 - 1] = a1i + t1r;
out[oidx2] = t1i - a1r;
out[oidx2 - 1] = a1i - t1r;
}
}
if (ido % 2 == 1)
return;
}
idx2 = 2 * idx1;
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
int oidx1 = out_off + idx2 + ido;
int iidx1 = in_off + ido - 1 + idx1;
out[oidx1] = -in[iidx1 + idx0];
out[oidx1 - 1] = in[iidx1];
}
}
/*-------------------------------------------------
radb2: Real FFT's backward processing of factor 2
-------------------------------------------------
void radb2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic;
float t1i, t1r, w1r, w1i;
int iw1 = offset;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int oidx1 = out_off + idx1;
int iidx1 = in_off + idx2;
int iidx2 = in_off + ido - 1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx1 + idx0] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx5 = i - 1 + iw1;
int idx6 = out_off + i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
w1r = wtable_r[idx5 - 1];
w1i = wtable_r[idx5];
int iidx1 = idx7 + idx2;
int iidx2 = idx8 + idx3;
int oidx1 = idx6 + idx1;
int oidx2 = idx6 + idx4;
t1r = in[iidx1 - 1] - in[iidx2 - 1];
t1i = in[iidx1] + in[iidx2];
float i1i = in[iidx1];
float i1r = in[iidx1 - 1];
float i2i = in[iidx2];
float i2r = in[iidx2 - 1];
out[oidx1 - 1] = i1r + i2r;
out[oidx1] = i1i - i2i;
out[oidx2 - 1] = w1r * t1r - w1i * t1i;
out[oidx2] = w1r * t1i + w1i * t1r;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int oidx1 = out_off + ido - 1 + idx1;
int iidx1 = in_off + idx2 + ido;
out[oidx1] = 2 * in[iidx1 - 1];
out[oidx1 + idx0] = -2 * in[iidx1];
}
}
/*-------------------------------------------------
radf3: Real FFT's forward processing of factor 3
-------------------------------------------------
void radf3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, di2, di3, cr2, dr2, dr3, ti2, ti3, tr2, tr3, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx3 = 2 * idx0;
int idx4 = (3 * k + 1) * ido;
int iidx1 = in_off + idx1;
int iidx2 = iidx1 + idx0;
int iidx3 = iidx1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
float i3r = in[iidx3];
cr2 = i2r + i3r;
out[out_off + 3 * idx1] = i1r + cr2;
out[out_off + idx4 + ido] = taui * (i3r - i2r);
out[out_off + ido - 1 + idx4] = i1r + taur * cr2;
}
if (ido == 1)
return;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int idx4 = 3 * idx3;
int idx5 = idx3 + idx0;
int idx6 = idx5 + idx0;
int idx7 = idx4 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx3;
int iidx2 = idx9 + idx5;
int iidx3 = idx9 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
cr2 = dr2 + dr3;
ci2 = di2 + di3;
tr2 = i1i + taur * cr2;
ti2 = i1r + taur * ci2;
tr3 = taui * (di2 - di3);
ti3 = taui * (dr3 - dr2);
int oidx1 = idx10 + idx4;
int oidx2 = idx11 + idx7;
int oidx3 = idx10 + idx8;
out[oidx1 - 1] = i1i + cr2;
out[oidx1] = i1r + ci2;
out[oidx2 - 1] = tr2 - tr3;
out[oidx2] = ti3 - ti2;
out[oidx3 - 1] = tr2 + tr3;
out[oidx3] = ti2 + ti3;
}
}
}
/*-------------------------------------------------
radb3: Real FFT's backward processing of factor 3
-------------------------------------------------
void radb3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, ci3, di2, di3, cr2, cr3, dr2, dr3, ti2, tr2, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int iidx1 = in_off + 3 * idx1;
int iidx2 = iidx1 + 2 * ido;
float i1i = in[iidx1];
tr2 = 2 * in[iidx2 - 1];
cr2 = i1i + taur * tr2;
ci3 = 2 * taui * in[iidx2];
out[out_off + idx1] = i1i + tr2;
out[out_off + (k + l1) * ido] = cr2 - ci3;
out[out_off + (k + 2 * l1) * ido] = cr2 + ci3;
}
if (ido == 1)
return;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 3 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx1 + idx0;
int idx6 = idx5 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
int idx9 = out_off + i;
int iidx1 = idx7 + idx2;
int iidx2 = idx7 + idx4;
int iidx3 = idx8 + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
tr2 = i2i + i3i;
cr2 = i1i + taur * tr2;
ti2 = i2r - i3r;
ci2 = i1r + taur * ti2;
cr3 = taui * (i2i - i3i);
ci3 = taui * (i2r + i3r);
dr2 = cr2 - ci3;
dr3 = cr2 + ci3;
di2 = ci2 + cr3;
di3 = ci2 - cr3;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int oidx1 = idx9 + idx1;
int oidx2 = idx9 + idx5;
int oidx3 = idx9 + idx6;
out[oidx1 - 1] = i1i + tr2;
out[oidx1] = i1r + ti2;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
}
}
}
/*-------------------------------------------------
radf4: Real FFT's forward processing of factor 4
-------------------------------------------------
void radf4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float hsqt2 = 0.707106781186547572737310929369414225f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = offset + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx3];
float i3r = in[in_off + idx4];
float i4r = in[in_off + idx5];
tr1 = i2r + i4r;
tr2 = i1r + i3r;
int oidx1 = out_off + idx2;
int oidx2 = out_off + idx6 + ido;
out[oidx1] = tr1 + tr2;
out[oidx2 - 1 + ido + ido] = tr2 - tr1;
out[oidx2 - 1] = i1r - i3r;
out[oidx2] = i4r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx1;
int iidx2 = idx9 + idx2;
int iidx3 = idx9 + idx3;
int iidx4 = idx9 + idx4;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
cr2 = w1r * i2i + w1i * i2r;
ci2 = w1r * i2r - w1i * i2i;
cr3 = w2r * i3i + w2i * i3r;
ci3 = w2r * i3r - w2i * i3i;
cr4 = w3r * i4i + w3i * i4r;
ci4 = w3r * i4r - w3i * i4i;
tr1 = cr2 + cr4;
tr4 = cr4 - cr2;
ti1 = ci2 + ci4;
ti4 = ci2 - ci4;
ti2 = i1r + ci3;
ti3 = i1r - ci3;
tr2 = i1i + cr3;
tr3 = i1i - cr3;
int oidx1 = idx10 + idx5;
int oidx2 = idx11 + idx6;
int oidx3 = idx10 + idx7;
int oidx4 = idx11 + idx8;
out[oidx1 - 1] = tr1 + tr2;
out[oidx4 - 1] = tr2 - tr1;
out[oidx1] = ti1 + ti2;
out[oidx4] = ti1 - ti2;
out[oidx3 - 1] = ti4 + tr3;
out[oidx2 - 1] = tr3 - ti4;
out[oidx3] = tr4 + ti3;
out[oidx2] = tr4 - ti3;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1i = in[idx9 - 1 + idx1];
float i2i = in[idx9 - 1 + idx3];
float i3i = in[idx9 - 1 + idx4];
float i4i = in[idx9 - 1 + idx5];
ti1 = -hsqt2 * (i2i + i4i);
tr1 = hsqt2 * (i2i - i4i);
out[idx10 - 1 + idx2] = tr1 + i1i;
out[idx10 - 1 + idx7] = i1i - tr1;
out[out_off + idx6] = ti1 - i3i;
out[out_off + idx8] = ti1 + i3i;
}
}
/*-------------------------------------------------
radb4: Real FFT's backward processing of factor 4
-------------------------------------------------
void radb4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float sqrt2 = 1.41421356237309514547462185873882845f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4;
float ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
float i1r = in[in_off + idx2];
float i2r = in[in_off + idx7];
float i3r = in[in_off + ido - 1 + idx8];
float i4r = in[in_off + ido - 1 + idx6];
tr1 = i1r - i3r;
tr2 = i1r + i3r;
tr3 = i4r + i4r;
tr4 = i2r + i2r;
out[out_off + idx1] = tr2 + tr3;
out[out_off + idx3] = tr1 - tr4;
out[out_off + idx4] = tr2 - tr3;
out[out_off + idx5] = tr1 + tr4;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx12 = in_off + i;
int idx13 = in_off + ic;
int idx14 = out_off + i;
int iidx1 = idx12 + idx5;
int iidx2 = idx13 + idx6;
int iidx3 = idx12 + idx7;
int iidx4 = idx13 + idx8;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
ti1 = i1r + i4r;
ti2 = i1r - i4r;
ti3 = i3r - i2r;
tr4 = i3r + i2r;
tr1 = i1i - i4i;
tr2 = i1i + i4i;
ti4 = i3i - i2i;
tr3 = i3i + i2i;
cr3 = tr2 - tr3;
ci3 = ti2 - ti3;
cr2 = tr1 - tr4;
cr4 = tr1 + tr4;
ci2 = ti1 + ti4;
ci4 = ti1 - ti4;
int oidx1 = idx14 + idx1;
int oidx2 = idx14 + idx2;
int oidx3 = idx14 + idx3;
int oidx4 = idx14 + idx4;
out[oidx1 - 1] = tr2 + tr3;
out[oidx1] = ti2 + ti3;
out[oidx2 - 1] = w1r * cr2 - w1i * ci2;
out[oidx2] = w1r * ci2 + w1i * cr2;
out[oidx3 - 1] = w2r * cr3 - w2i * ci3;
out[oidx3] = w2r * ci3 + w2i * cr3;
out[oidx4 - 1] = w3r * cr4 - w3i * ci4;
out[oidx4] = w3r * ci4 + w3i * cr4;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1r = in[idx9 - 1 + idx2];
float i2r = in[idx9 - 1 + idx7];
float i3r = in[in_off + idx6];
float i4r = in[in_off + idx8];
ti1 = i3r + i4r;
ti2 = i4r - i3r;
tr1 = i1r - i2r;
tr2 = i1r + i2r;
out[idx10 - 1 + idx1] = tr2 + tr2;
out[idx10 - 1 + idx3] = sqrt2 * (tr1 - ti1);
out[idx10 - 1 + idx4] = ti2 + ti2;
out[idx10 - 1 + idx5] = -sqrt2 * (tr1 + ti1);
}
}
/*-------------------------------------------------
radf5: Real FFT's forward processing of factor 5
-------------------------------------------------
void radf5(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float tr11 = 0.309016994374947451262869435595348477f;
final float ti11 = 0.951056516295153531181938433292089030f;
final float tr12 = -0.809016994374947340240566973079694435f;
final float ti12 = 0.587785252292473248125759255344746634f;
int i, ic;
float ci2, di2, ci4, ci5, di3, di4, di5, ci3, cr2, cr3, dr2, dr3, dr4, dr5, cr5, cr4, ti2, ti3, ti5, ti4, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
int iw1, iw2, iw3, iw4;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
iw4 = iw3 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
int idx11 = out_off + ido - 1;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx7];
float i3r = in[in_off + idx8];
float i4r = in[in_off + idx9];
float i5r = in[in_off + idx10];
cr2 = i5r + i2r;
ci5 = i5r - i2r;
cr3 = i4r + i3r;
ci4 = i4r - i3r;
out[out_off + idx2] = i1r + cr2 + cr3;
out[idx11 + idx3] = i1r + tr11 * cr2 + tr12 * cr3;
out[out_off + idx4] = ti11 * ci5 + ti12 * ci4;
out[idx11 + idx5] = i1r + tr12 * cr2 + tr11 * cr3;
out[out_off + idx6] = ti12 * ci5 - ti11 * ci4;
}
if (ido == 1)
return;
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
for (i = 2; i < ido; i += 2) {
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
int widx4 = i - 1 + iw4;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
w4r = wtable_r[widx4 - 1];
w4i = wtable_r[widx4];
ic = ido - i;
int idx15 = in_off + i;
int idx16 = out_off + i;
int idx17 = out_off + ic;
int iidx1 = idx15 + idx1;
int iidx2 = idx15 + idx7;
int iidx3 = idx15 + idx8;
int iidx4 = idx15 + idx9;
int iidx5 = idx15 + idx10;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
dr4 = w3r * i4i + w3i * i4r;
di4 = w3r * i4r - w3i * i4i;
dr5 = w4r * i5i + w4i * i5r;
di5 = w4r * i5r - w4i * i5i;
cr2 = dr2 + dr5;
ci5 = dr5 - dr2;
cr5 = di2 - di5;
ci2 = di2 + di5;
cr3 = dr3 + dr4;
ci4 = dr4 - dr3;
cr4 = di3 - di4;
ci3 = di3 + di4;
tr2 = i1i + tr11 * cr2 + tr12 * cr3;
ti2 = i1r + tr11 * ci2 + tr12 * ci3;
tr3 = i1i + tr12 * cr2 + tr11 * cr3;
ti3 = i1r + tr12 * ci2 + tr11 * ci3;
tr5 = ti11 * cr5 + ti12 * cr4;
ti5 = ti11 * ci5 + ti12 * ci4;
tr4 = ti12 * cr5 - ti11 * cr4;
ti4 = ti12 * ci5 - ti11 * ci4;
int oidx1 = idx16 + idx2;
int oidx2 = idx17 + idx3;
int oidx3 = idx16 + idx4;
int oidx4 = idx17 + idx5;
int oidx5 = idx16 + idx6;
out[oidx1 - 1] = i1i + cr2 + cr3;
out[oidx1] = i1r + ci2 + ci3;
out[oidx3 - 1] = tr2 + tr5;
out[oidx2 - 1] = tr2 - tr5;
out[oidx3] = ti2 + ti5;
out[oidx2] = ti5 - ti2;
out[oidx5 - 1] = tr3 + tr4;
out[oidx4 - 1] = tr3 - tr4;
out[oidx5] = ti3 + ti4;
out[oidx4] = ti4 - ti3;
}
}
}
/*-------------------------------------------------
radb5: Real FFT's backward processing of factor 5
------------------------------------------------- | FloatFFT::radb5 | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
void radfg(final int ido, final int ip, final int l1, final int idl1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int idij, ipph, j2, ic, jc, lc, is, nbd;
float dc2, ai1, ai2, ar1, ar2, ds2, dcp, arg, dsp, ar1h, ar2h, w1r, w1i;
int iw1 = offset;
arg = TWO_PI / (float) ip;
dcp = (float)Math.cos(arg);
dsp = (float)Math.sin(arg);
ipph = (ip + 1) / 2;
nbd = (ido - 1) / 2;
if (ido != 1) {
if (idl1 >= 0) System.arraycopy(in, in_off, out, out_off, idl1);
for (int j = 1; j < ip; j++) {
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx2 = k * ido + idx1;
out[out_off + idx2] = in[in_off + idx2];
}
}
if (nbd <= l1) {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
idij = is - 1;
int idx1 = j * l1 * ido;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
int idx4 = in_off + i;
int idx5 = out_off + i;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int oidx1 = idx5 + idx3;
int iidx1 = idx4 + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
out[oidx1 - 1] = w1r * i1i + w1i * i1r;
out[oidx1] = w1r * i1r - w1i * i1i;
}
}
}
} else {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
idij = is - 1;
int idx3 = k * ido + idx1;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
int oidx1 = out_off + i + idx3;
int iidx1 = in_off + i + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
out[oidx1 - 1] = w1r * i1i + w1i * i1r;
out[oidx1] = w1r * i1r - w1i * i1i;
}
}
}
}
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
for (int i = 2; i < ido; i += 2) {
int idx5 = in_off + i;
int idx6 = out_off + i;
int iidx1 = idx5 + idx3;
int iidx2 = idx5 + idx4;
int oidx1 = idx6 + idx3;
int oidx2 = idx6 + idx4;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx1] = o1r + o2r;
in[iidx2 - 1] = o1r - o2r;
in[iidx2] = o2i - o1i;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int i = 2; i < ido; i += 2) {
int idx5 = in_off + i;
int idx6 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
int iidx1 = idx5 + idx3;
int iidx2 = idx5 + idx4;
int oidx1 = idx6 + idx3;
int oidx2 = idx6 + idx4;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx1] = o1r + o2r;
in[iidx2 - 1] = o1r - o2r;
in[iidx2] = o2i - o1i;
}
}
}
}
} else {
System.arraycopy(out, out_off, in, in_off, idl1);
}
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
int oidx1 = out_off + idx3;
int oidx2 = out_off + idx4;
float o1r = out[oidx1];
float o2r = out[oidx2];
in[in_off + idx3] = o1r + o2r;
in[in_off + idx4] = o2r - o1r;
}
}
ar1 = 1;
ai1 = 0;
int idx0 = (ip - 1) * idl1;
for (int l = 1; l < ipph; l++) {
lc = ip - l;
ar1h = dcp * ar1 - dsp * ai1;
ai1 = dcp * ai1 + dsp * ar1;
ar1 = ar1h;
int idx1 = l * idl1;
int idx2 = lc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx3 = out_off + ik;
int idx4 = in_off + ik;
out[idx3 + idx1] = in[idx4] + ar1 * in[idx4 + idl1];
out[idx3 + idx2] = ai1 * in[idx4 + idx0];
}
dc2 = ar1;
ds2 = ai1;
ar2 = ar1;
ai2 = ai1;
for (int j = 2; j < ipph; j++) {
jc = ip - j;
ar2h = dc2 * ar2 - ds2 * ai2;
ai2 = dc2 * ai2 + ds2 * ar2;
ar2 = ar2h;
int idx3 = j * idl1;
int idx4 = jc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx5 = out_off + ik;
int idx6 = in_off + ik;
out[idx5 + idx1] += ar2 * in[idx6 + idx3];
out[idx5 + idx2] += ai2 * in[idx6 + idx4];
}
}
}
for (int j = 1; j < ipph; j++) {
int idx1 = j * idl1;
for (int ik = 0; ik < idl1; ik++) {
out[out_off + ik] += in[in_off + ik + idx1];
}
}
if (ido >= l1) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = idx1 * ip;
for (int i = 0; i < ido; i++) {
in[in_off + i + idx2] = out[out_off + i + idx1];
}
}
} else {
for (int i = 0; i < ido; i++) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
in[in_off + i + idx1 * ip] = out[out_off + i + idx1];
}
}
}
int idx01 = ip * ido;
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido;
int idx5 = idx4 + idx1;
int idx6 = idx4 + idx2;
int idx7 = k * idx01;
in[in_off + ido - 1 + idx3 - ido + idx7] = out[out_off + idx5];
in[in_off + idx3 + idx7] = out[out_off + idx6];
}
}
if (ido == 1)
return;
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * idx01;
int idx5 = k * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx6 = in_off + i;
int idx7 = in_off + ic;
int idx8 = out_off + i;
int iidx1 = idx6 + idx3 + idx4;
int iidx2 = idx7 + idx3 - ido + idx4;
int oidx1 = idx8 + idx5 + idx1;
int oidx2 = idx8 + idx5 + idx2;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx2 - 1] = o1i - o2i;
in[iidx1] = o1r + o2r;
in[iidx2] = o2r - o1r;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx6 = in_off + i;
int idx7 = in_off + ic;
int idx8 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx4 = k * idx01;
int idx5 = k * ido;
int iidx1 = idx6 + idx3 + idx4;
int iidx2 = idx7 + idx3 - ido + idx4;
int oidx1 = idx8 + idx5 + idx1;
int oidx2 = idx8 + idx5 + idx2;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx2 - 1] = o1i - o2i;
in[iidx1] = o1r + o2r;
in[iidx2] = o2r - o1r;
}
}
}
}
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. This method computes the full real inverse transform, i.e. you will get
the same result as from <code>complexInverse</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
public void realInverseFull(final float[] a, final int offa, boolean scale) {
final int twon = 2 * n;
switch (plan) {
case SPLIT_RADIX:
realInverse2(a, offa, scale);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n / 2 > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
Future<?>[] futures = new Future[nthreads];
int k = n / 2 / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n / 2 : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
int idx1, idx2;
for (int k = firstIdx; k < lastIdx; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
int idx1, idx2;
for (int k = 0; k < n / 2; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
a[offa + n] = -a[offa + 1];
a[offa + 1] = 0;
break;
case MIXED_RADIX:
rfftf(a, offa);
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
} else {
m = (n + 1) / 2;
}
for (int k = 1; k < m; k++) {
int idx1 = offa + 2 * k;
int idx2 = offa + twon - 2 * k;
a[idx1] = -a[idx1];
a[idx2 + 1] = -a[idx1];
a[idx2] = a[idx1 - 1];
}
for (int k = 1; k < n; k++) {
int idx = offa + n - k;
float tmp = a[idx + 1];
a[idx + 1] = a[idx];
a[idx] = tmp;
}
a[offa + 1] = 0;
break;
case BLUESTEIN:
bluestein_real_full(a, offa, 1);
if (scale) {
scale(n, a, offa, true);
}
break;
}
}
private void realInverse2(float[] a, int offa, boolean scale) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
float xi;
if (n > 4) {
cftfsub(n, a, offa, ip, nw, w);
rftbsub(n, a, offa, nc, w, nw);
} else if (n == 4) {
cftbsub(n, a, offa, ip, nw, w);
}
xi = a[offa] - a[offa + 1];
a[offa] += a[offa + 1];
a[offa + 1] = xi;
if (scale) {
scale(n, a, offa, false);
}
break;
case MIXED_RADIX:
rfftf(a, offa);
for (int k = n - 1; k >= 2; k--) {
int idx = offa + k;
float tmp = a[idx];
a[idx] = a[idx - 1];
a[idx - 1] = tmp;
}
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
for (int i = 1; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
} else {
m = (n - 1) / 2;
for (int i = 0; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
}
break;
case BLUESTEIN:
bluestein_real_inverse2(a, offa);
if (scale) {
scale(n, a, offa, false);
}
break;
}
}
private static int getReminder(int n, int[] factors) {
int reminder = n;
if (n <= 0) {
throw new IllegalArgumentException("n must be positive integer");
}
for (int i = 0; i < factors.length && reminder != 1; i++) {
int factor = factors[i];
while ((reminder % factor) == 0) {
reminder /= factor;
}
}
return reminder;
}
/* -------- initializing routines --------
/*---------------------------------------------------------
cffti: initialization of Complex FFT
--------------------------------------------------------
void cffti(int n, int offw) {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[offw + nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[offw + idx + 1] = wtable[offw + idx];
}
wtable[offw + 2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[offw + fourn] = n;
wtable[offw + 1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[offw + k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[offw + i - 1 + twon] = 1;
wtable[offw + i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[offw + idx - 1] = (float)Math.cos(arg);
wtable[offw + idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[offw + idx1 - 1] = wtable[offw + idx2 - 1];
wtable[offw + idx1] = wtable[offw + idx2];
}
}
l1 = l2;
}
}
void cffti() {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[idx + 1] = wtable[idx];
}
wtable[2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[fourn] = n;
wtable[1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[i - 1 + twon] = 1;
wtable[i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[idx - 1] = (float)Math.cos(arg);
wtable[idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[idx1 - 1] = wtable[idx2 - 1];
wtable[idx1] = wtable[idx2];
}
}
l1 = l2;
}
}
void rffti() {
if (n == 1)
return;
final int twon = 2 * n;
float argh;
int ntry = 0, i, j;
float argld;
int k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, is, nq, nr;
float arg;
int ido, ipm;
int nfm1;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
++j;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
++nf;
wtable_r[nf + 1 + twon] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + twon;
wtable_r[idx + 1] = wtable_r[idx];
}
wtable_r[2 + twon] = 2;
}
} while (nl != 1);
break;
}
wtable_r[twon] = n;
wtable_r[1 + twon] = nf;
argh = TWO_PI / (float) (n);
is = 0;
nfm1 = nf - 1;
l1 = 1;
if (nfm1 == 0)
return;
for (k1 = 1; k1 <= nfm1; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
ipm = ip - 1;
for (j = 1; j <= ipm; ++j) {
ld += l1;
i = is;
argld = (float) ld * argh;
fi = 0;
for (ii = 3; ii <= ido; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + n;
wtable_r[idx - 2] = (float)Math.cos(arg);
wtable_r[idx - 1] = (float)Math.sin(arg);
}
is += ido;
}
l1 = l2;
}
}
private void bluesteini() {
int k = 0;
float arg;
float pi_n = PI / n;
bk1[0] = 1;
bk1[1] = 0;
for (int i = 1; i < n; i++) {
k += 2 * i - 1;
if (k >= 2 * n)
k -= 2 * n;
arg = pi_n * k;
bk1[2 * i] = (float)Math.cos(arg);
bk1[2 * i + 1] = (float)Math.sin(arg);
}
float scale = (float)(1.0 / nBluestein);
bk2[0] = bk1[0] * scale;
bk2[1] = bk1[1] * scale;
for (int i = 2; i < 2 * n; i += 2) {
bk2[i] = bk1[i] * scale;
bk2[i + 1] = bk1[i + 1] * scale;
bk2[2 * nBluestein - i] = bk2[i];
bk2[2 * nBluestein - i + 1] = bk2[i + 1];
}
cftbsub(2 * nBluestein, bk2, 0, ip, nw, w);
}
private void makewt(int nw) {
int j, nwh, nw0, nw1;
float delta, wn4r, wk1r, wk1i, wk3r, wk3i;
float delta2, deltaj, deltaj3;
ip[0] = nw;
ip[1] = 1;
if (nw > 2) {
nwh = nw >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nwh);
delta2 = delta * 2;
wn4r = (float)Math.cos(delta * nwh);
w[0] = 1;
w[1] = wn4r;
if (nwh == 4) {
w[2] = (float)Math.cos(delta2);
w[3] = (float)Math.sin(delta2);
} else if (nwh > 4) {
makeipt(nw);
w[2] = (float)(0.5 / Math.cos(delta2));
w[3] = (float)(0.5 / Math.cos(delta * 6));
for (j = 4; j < nwh; j += 4) {
deltaj = delta * j;
deltaj3 = 3 * deltaj;
w[j] = (float)Math.cos(deltaj);
w[j + 1] = (float)Math.sin(deltaj);
w[j + 2] = (float)Math.cos(deltaj3);
w[j + 3] = (float)-Math.sin(deltaj3);
}
}
nw0 = 0;
while (nwh > 2) {
nw1 = nw0 + nwh;
nwh >>= 1;
w[nw1] = 1;
w[nw1 + 1] = wn4r;
if (nwh == 4) {
wk1r = w[nw0 + 4];
wk1i = w[nw0 + 5];
w[nw1 + 2] = wk1r;
w[nw1 + 3] = wk1i;
} else if (nwh > 4) {
wk1r = w[nw0 + 4];
wk3r = w[nw0 + 6];
w[nw1 + 2] = (float)(0.5 / wk1r);
w[nw1 + 3] = (float)(0.5 / wk3r);
for (j = 4; j < nwh; j += 4) {
int idx1 = nw0 + 2 * j;
int idx2 = nw1 + j;
wk1r = w[idx1];
wk1i = w[idx1 + 1];
wk3r = w[idx1 + 2];
wk3i = w[idx1 + 3];
w[idx2] = wk1r;
w[idx2 + 1] = wk1i;
w[idx2 + 2] = wk3r;
w[idx2 + 3] = wk3i;
}
}
nw0 = nw1;
}
}
}
private void makeipt(int nw) {
int j, l, m, m2, p, q;
ip[2] = 0;
ip[3] = 16;
m = 2;
for (l = nw; l > 32; l >>= 2) {
m2 = m << 1;
q = m2 << 3;
for (j = m; j < m2; j++) {
p = ip[j] << 2;
ip[m + j] = p;
ip[m2 + j] = p + q;
}
m = m2;
}
}
private void makect(int nc, float[] c, int startc) {
int j, nch;
float delta, deltaj;
ip[1] = nc;
if (nc > 1) {
nch = nc >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nch);
c[startc] = (float)Math.cos(delta * nch);
c[startc + nch] = (float)(0.5 * c[startc]);
for (j = 1; j < nch; j++) {
deltaj = delta * j;
c[startc + j] = (float)(0.5 * Math.cos(deltaj));
c[startc + nc - j] = (float)(0.5 * Math.sin(deltaj));
}
}
}
private void bluestein_complex(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_full(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_forward(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] + bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = -bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] + bk1[n] * ak[n];
}
}
private void bluestein_real_inverse(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
if (n % 2 == 0) {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n] = a[offa + 1] * bk1[n];
ak[n + 1] = a[offa + 1] * bk1[n + 1];
for (int i = n / 2 + 1; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
} else {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n - 1] = a[offa + n - 1] * bk1[n - 1] - a[offa + 1] * bk1[n];
ak[n] = a[offa + n - 1] * bk1[n] + a[offa + 1] * bk1[n - 1];
ak[n + 1] = a[offa + n - 1] * bk1[n + 1] + a[offa + 1] * bk1[n + 2];
ak[n + 2] = a[offa + n - 1] * bk1[n + 2] - a[offa + 1] * bk1[n + 1];
for (int i = (n - 1) / 2 + 2; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
}
private void bluestein_real_inverse2(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] - bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] - bk1[n] * ak[n];
}
}
/*---------------------------------------------------------
rfftf1: further processing of Real forward FFT
--------------------------------------------------------
void rfftf(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, kh, nf, ip, iw, ido, idl1;
final float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 1;
l2 = n;
iw = twon - 1;
for (int k1 = 1; k1 <= nf; ++k1) {
kh = nf - k1;
ip = (int) wtable_r[kh + 2 + twon];
l1 = l2 / ip;
ido = n / l2;
idl1 = ido * l1;
iw -= (ip - 1) * ido;
na = 1 - na;
switch (ip) {
case 2:
if (na == 0) {
radf2(ido, l1, a, offa, ch, 0, iw);
} else {
radf2(ido, l1, ch, 0, a, offa, iw);
}
break;
case 3:
if (na == 0) {
radf3(ido, l1, a, offa, ch, 0, iw);
} else {
radf3(ido, l1, ch, 0, a, offa, iw);
}
break;
case 4:
if (na == 0) {
radf4(ido, l1, a, offa, ch, 0, iw);
} else {
radf4(ido, l1, ch, 0, a, offa, iw);
}
break;
case 5:
if (na == 0) {
radf5(ido, l1, a, offa, ch, 0, iw);
} else {
radf5(ido, l1, ch, 0, a, offa, iw);
}
break;
default:
if (ido == 1)
na = 1 - na;
if (na == 0) {
radfg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
na = 1;
} else {
radfg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
na = 0;
}
break;
}
l2 = l1;
}
if (na == 1)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*---------------------------------------------------------
rfftb1: further processing of Real backward FFT
--------------------------------------------------------
void rfftb(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, nf, ip, iw, ido, idl1;
float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 0;
l1 = 1;
iw = n;
for (int k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
l2 = ip * l1;
ido = n / l2;
idl1 = ido * l1;
switch (ip) {
case 2:
if (na == 0) {
radb2(ido, l1, a, offa, ch, 0, iw);
} else {
radb2(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
radb3(ido, l1, a, offa, ch, 0, iw);
} else {
radb3(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 4:
if (na == 0) {
radb4(ido, l1, a, offa, ch, 0, iw);
} else {
radb4(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
radb5(ido, l1, a, offa, ch, 0, iw);
} else {
radb5(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
default:
if (na == 0) {
radbg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
} else {
radbg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
}
if (ido == 1)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * ido;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*-------------------------------------------------
radf2: Real FFT's forward processing of factor 2
-------------------------------------------------
void radf2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic, idx0, idx1, idx2, idx3, idx4;
float t1i, t1r, w1r, w1i;
int iw1;
iw1 = offset;
idx0 = l1 * ido;
idx1 = 2 * ido;
for (int k = 0; k < l1; k++) {
int oidx1 = out_off + k * idx1;
int oidx2 = oidx1 + idx1 - 1;
int iidx1 = in_off + k * ido;
int iidx2 = iidx1 + idx0;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx2] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
idx2 = 2 * idx1;
idx3 = idx2 + ido;
idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int oidx1 = out_off + i + idx2;
int oidx2 = out_off + ic + idx3;
int iidx1 = in_off + i + idx1;
int iidx2 = in_off + i + idx4;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
t1r = w1r * a2i + w1i * a2r;
t1i = w1r * a2r - w1i * a2i;
out[oidx1] = a1r + t1i;
out[oidx1 - 1] = a1i + t1r;
out[oidx2] = t1i - a1r;
out[oidx2 - 1] = a1i - t1r;
}
}
if (ido % 2 == 1)
return;
}
idx2 = 2 * idx1;
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
int oidx1 = out_off + idx2 + ido;
int iidx1 = in_off + ido - 1 + idx1;
out[oidx1] = -in[iidx1 + idx0];
out[oidx1 - 1] = in[iidx1];
}
}
/*-------------------------------------------------
radb2: Real FFT's backward processing of factor 2
-------------------------------------------------
void radb2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic;
float t1i, t1r, w1r, w1i;
int iw1 = offset;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int oidx1 = out_off + idx1;
int iidx1 = in_off + idx2;
int iidx2 = in_off + ido - 1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx1 + idx0] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx5 = i - 1 + iw1;
int idx6 = out_off + i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
w1r = wtable_r[idx5 - 1];
w1i = wtable_r[idx5];
int iidx1 = idx7 + idx2;
int iidx2 = idx8 + idx3;
int oidx1 = idx6 + idx1;
int oidx2 = idx6 + idx4;
t1r = in[iidx1 - 1] - in[iidx2 - 1];
t1i = in[iidx1] + in[iidx2];
float i1i = in[iidx1];
float i1r = in[iidx1 - 1];
float i2i = in[iidx2];
float i2r = in[iidx2 - 1];
out[oidx1 - 1] = i1r + i2r;
out[oidx1] = i1i - i2i;
out[oidx2 - 1] = w1r * t1r - w1i * t1i;
out[oidx2] = w1r * t1i + w1i * t1r;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int oidx1 = out_off + ido - 1 + idx1;
int iidx1 = in_off + idx2 + ido;
out[oidx1] = 2 * in[iidx1 - 1];
out[oidx1 + idx0] = -2 * in[iidx1];
}
}
/*-------------------------------------------------
radf3: Real FFT's forward processing of factor 3
-------------------------------------------------
void radf3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, di2, di3, cr2, dr2, dr3, ti2, ti3, tr2, tr3, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx3 = 2 * idx0;
int idx4 = (3 * k + 1) * ido;
int iidx1 = in_off + idx1;
int iidx2 = iidx1 + idx0;
int iidx3 = iidx1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
float i3r = in[iidx3];
cr2 = i2r + i3r;
out[out_off + 3 * idx1] = i1r + cr2;
out[out_off + idx4 + ido] = taui * (i3r - i2r);
out[out_off + ido - 1 + idx4] = i1r + taur * cr2;
}
if (ido == 1)
return;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int idx4 = 3 * idx3;
int idx5 = idx3 + idx0;
int idx6 = idx5 + idx0;
int idx7 = idx4 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx3;
int iidx2 = idx9 + idx5;
int iidx3 = idx9 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
cr2 = dr2 + dr3;
ci2 = di2 + di3;
tr2 = i1i + taur * cr2;
ti2 = i1r + taur * ci2;
tr3 = taui * (di2 - di3);
ti3 = taui * (dr3 - dr2);
int oidx1 = idx10 + idx4;
int oidx2 = idx11 + idx7;
int oidx3 = idx10 + idx8;
out[oidx1 - 1] = i1i + cr2;
out[oidx1] = i1r + ci2;
out[oidx2 - 1] = tr2 - tr3;
out[oidx2] = ti3 - ti2;
out[oidx3 - 1] = tr2 + tr3;
out[oidx3] = ti2 + ti3;
}
}
}
/*-------------------------------------------------
radb3: Real FFT's backward processing of factor 3
-------------------------------------------------
void radb3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, ci3, di2, di3, cr2, cr3, dr2, dr3, ti2, tr2, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int iidx1 = in_off + 3 * idx1;
int iidx2 = iidx1 + 2 * ido;
float i1i = in[iidx1];
tr2 = 2 * in[iidx2 - 1];
cr2 = i1i + taur * tr2;
ci3 = 2 * taui * in[iidx2];
out[out_off + idx1] = i1i + tr2;
out[out_off + (k + l1) * ido] = cr2 - ci3;
out[out_off + (k + 2 * l1) * ido] = cr2 + ci3;
}
if (ido == 1)
return;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 3 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx1 + idx0;
int idx6 = idx5 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
int idx9 = out_off + i;
int iidx1 = idx7 + idx2;
int iidx2 = idx7 + idx4;
int iidx3 = idx8 + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
tr2 = i2i + i3i;
cr2 = i1i + taur * tr2;
ti2 = i2r - i3r;
ci2 = i1r + taur * ti2;
cr3 = taui * (i2i - i3i);
ci3 = taui * (i2r + i3r);
dr2 = cr2 - ci3;
dr3 = cr2 + ci3;
di2 = ci2 + cr3;
di3 = ci2 - cr3;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int oidx1 = idx9 + idx1;
int oidx2 = idx9 + idx5;
int oidx3 = idx9 + idx6;
out[oidx1 - 1] = i1i + tr2;
out[oidx1] = i1r + ti2;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
}
}
}
/*-------------------------------------------------
radf4: Real FFT's forward processing of factor 4
-------------------------------------------------
void radf4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float hsqt2 = 0.707106781186547572737310929369414225f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = offset + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx3];
float i3r = in[in_off + idx4];
float i4r = in[in_off + idx5];
tr1 = i2r + i4r;
tr2 = i1r + i3r;
int oidx1 = out_off + idx2;
int oidx2 = out_off + idx6 + ido;
out[oidx1] = tr1 + tr2;
out[oidx2 - 1 + ido + ido] = tr2 - tr1;
out[oidx2 - 1] = i1r - i3r;
out[oidx2] = i4r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx1;
int iidx2 = idx9 + idx2;
int iidx3 = idx9 + idx3;
int iidx4 = idx9 + idx4;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
cr2 = w1r * i2i + w1i * i2r;
ci2 = w1r * i2r - w1i * i2i;
cr3 = w2r * i3i + w2i * i3r;
ci3 = w2r * i3r - w2i * i3i;
cr4 = w3r * i4i + w3i * i4r;
ci4 = w3r * i4r - w3i * i4i;
tr1 = cr2 + cr4;
tr4 = cr4 - cr2;
ti1 = ci2 + ci4;
ti4 = ci2 - ci4;
ti2 = i1r + ci3;
ti3 = i1r - ci3;
tr2 = i1i + cr3;
tr3 = i1i - cr3;
int oidx1 = idx10 + idx5;
int oidx2 = idx11 + idx6;
int oidx3 = idx10 + idx7;
int oidx4 = idx11 + idx8;
out[oidx1 - 1] = tr1 + tr2;
out[oidx4 - 1] = tr2 - tr1;
out[oidx1] = ti1 + ti2;
out[oidx4] = ti1 - ti2;
out[oidx3 - 1] = ti4 + tr3;
out[oidx2 - 1] = tr3 - ti4;
out[oidx3] = tr4 + ti3;
out[oidx2] = tr4 - ti3;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1i = in[idx9 - 1 + idx1];
float i2i = in[idx9 - 1 + idx3];
float i3i = in[idx9 - 1 + idx4];
float i4i = in[idx9 - 1 + idx5];
ti1 = -hsqt2 * (i2i + i4i);
tr1 = hsqt2 * (i2i - i4i);
out[idx10 - 1 + idx2] = tr1 + i1i;
out[idx10 - 1 + idx7] = i1i - tr1;
out[out_off + idx6] = ti1 - i3i;
out[out_off + idx8] = ti1 + i3i;
}
}
/*-------------------------------------------------
radb4: Real FFT's backward processing of factor 4
-------------------------------------------------
void radb4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float sqrt2 = 1.41421356237309514547462185873882845f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4;
float ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
float i1r = in[in_off + idx2];
float i2r = in[in_off + idx7];
float i3r = in[in_off + ido - 1 + idx8];
float i4r = in[in_off + ido - 1 + idx6];
tr1 = i1r - i3r;
tr2 = i1r + i3r;
tr3 = i4r + i4r;
tr4 = i2r + i2r;
out[out_off + idx1] = tr2 + tr3;
out[out_off + idx3] = tr1 - tr4;
out[out_off + idx4] = tr2 - tr3;
out[out_off + idx5] = tr1 + tr4;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx12 = in_off + i;
int idx13 = in_off + ic;
int idx14 = out_off + i;
int iidx1 = idx12 + idx5;
int iidx2 = idx13 + idx6;
int iidx3 = idx12 + idx7;
int iidx4 = idx13 + idx8;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
ti1 = i1r + i4r;
ti2 = i1r - i4r;
ti3 = i3r - i2r;
tr4 = i3r + i2r;
tr1 = i1i - i4i;
tr2 = i1i + i4i;
ti4 = i3i - i2i;
tr3 = i3i + i2i;
cr3 = tr2 - tr3;
ci3 = ti2 - ti3;
cr2 = tr1 - tr4;
cr4 = tr1 + tr4;
ci2 = ti1 + ti4;
ci4 = ti1 - ti4;
int oidx1 = idx14 + idx1;
int oidx2 = idx14 + idx2;
int oidx3 = idx14 + idx3;
int oidx4 = idx14 + idx4;
out[oidx1 - 1] = tr2 + tr3;
out[oidx1] = ti2 + ti3;
out[oidx2 - 1] = w1r * cr2 - w1i * ci2;
out[oidx2] = w1r * ci2 + w1i * cr2;
out[oidx3 - 1] = w2r * cr3 - w2i * ci3;
out[oidx3] = w2r * ci3 + w2i * cr3;
out[oidx4 - 1] = w3r * cr4 - w3i * ci4;
out[oidx4] = w3r * ci4 + w3i * cr4;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1r = in[idx9 - 1 + idx2];
float i2r = in[idx9 - 1 + idx7];
float i3r = in[in_off + idx6];
float i4r = in[in_off + idx8];
ti1 = i3r + i4r;
ti2 = i4r - i3r;
tr1 = i1r - i2r;
tr2 = i1r + i2r;
out[idx10 - 1 + idx1] = tr2 + tr2;
out[idx10 - 1 + idx3] = sqrt2 * (tr1 - ti1);
out[idx10 - 1 + idx4] = ti2 + ti2;
out[idx10 - 1 + idx5] = -sqrt2 * (tr1 + ti1);
}
}
/*-------------------------------------------------
radf5: Real FFT's forward processing of factor 5
-------------------------------------------------
void radf5(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float tr11 = 0.309016994374947451262869435595348477f;
final float ti11 = 0.951056516295153531181938433292089030f;
final float tr12 = -0.809016994374947340240566973079694435f;
final float ti12 = 0.587785252292473248125759255344746634f;
int i, ic;
float ci2, di2, ci4, ci5, di3, di4, di5, ci3, cr2, cr3, dr2, dr3, dr4, dr5, cr5, cr4, ti2, ti3, ti5, ti4, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
int iw1, iw2, iw3, iw4;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
iw4 = iw3 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
int idx11 = out_off + ido - 1;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx7];
float i3r = in[in_off + idx8];
float i4r = in[in_off + idx9];
float i5r = in[in_off + idx10];
cr2 = i5r + i2r;
ci5 = i5r - i2r;
cr3 = i4r + i3r;
ci4 = i4r - i3r;
out[out_off + idx2] = i1r + cr2 + cr3;
out[idx11 + idx3] = i1r + tr11 * cr2 + tr12 * cr3;
out[out_off + idx4] = ti11 * ci5 + ti12 * ci4;
out[idx11 + idx5] = i1r + tr12 * cr2 + tr11 * cr3;
out[out_off + idx6] = ti12 * ci5 - ti11 * ci4;
}
if (ido == 1)
return;
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
for (i = 2; i < ido; i += 2) {
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
int widx4 = i - 1 + iw4;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
w4r = wtable_r[widx4 - 1];
w4i = wtable_r[widx4];
ic = ido - i;
int idx15 = in_off + i;
int idx16 = out_off + i;
int idx17 = out_off + ic;
int iidx1 = idx15 + idx1;
int iidx2 = idx15 + idx7;
int iidx3 = idx15 + idx8;
int iidx4 = idx15 + idx9;
int iidx5 = idx15 + idx10;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
dr4 = w3r * i4i + w3i * i4r;
di4 = w3r * i4r - w3i * i4i;
dr5 = w4r * i5i + w4i * i5r;
di5 = w4r * i5r - w4i * i5i;
cr2 = dr2 + dr5;
ci5 = dr5 - dr2;
cr5 = di2 - di5;
ci2 = di2 + di5;
cr3 = dr3 + dr4;
ci4 = dr4 - dr3;
cr4 = di3 - di4;
ci3 = di3 + di4;
tr2 = i1i + tr11 * cr2 + tr12 * cr3;
ti2 = i1r + tr11 * ci2 + tr12 * ci3;
tr3 = i1i + tr12 * cr2 + tr11 * cr3;
ti3 = i1r + tr12 * ci2 + tr11 * ci3;
tr5 = ti11 * cr5 + ti12 * cr4;
ti5 = ti11 * ci5 + ti12 * ci4;
tr4 = ti12 * cr5 - ti11 * cr4;
ti4 = ti12 * ci5 - ti11 * ci4;
int oidx1 = idx16 + idx2;
int oidx2 = idx17 + idx3;
int oidx3 = idx16 + idx4;
int oidx4 = idx17 + idx5;
int oidx5 = idx16 + idx6;
out[oidx1 - 1] = i1i + cr2 + cr3;
out[oidx1] = i1r + ci2 + ci3;
out[oidx3 - 1] = tr2 + tr5;
out[oidx2 - 1] = tr2 - tr5;
out[oidx3] = ti2 + ti5;
out[oidx2] = ti5 - ti2;
out[oidx5 - 1] = tr3 + tr4;
out[oidx4 - 1] = tr3 - tr4;
out[oidx5] = ti3 + ti4;
out[oidx4] = ti4 - ti3;
}
}
}
/*-------------------------------------------------
radb5: Real FFT's backward processing of factor 5
-------------------------------------------------
void radb5(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float tr11 = 0.309016994374947451262869435595348477f;
final float ti11 = 0.951056516295153531181938433292089030f;
final float tr12 = -0.809016994374947340240566973079694435f;
final float ti12 = 0.587785252292473248125759255344746634f;
int i, ic;
float ci2, ci3, ci4, ci5, di3, di4, di5, di2, cr2, cr3, cr5, cr4, ti2, ti3, ti4, ti5, dr3, dr4, dr5, dr2, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
int iw1, iw2, iw3, iw4;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
iw4 = iw3 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
int idx11 = in_off + ido - 1;
float i1r = in[in_off + idx2];
ti5 = 2 * in[in_off + idx4];
ti4 = 2 * in[in_off + idx6];
tr2 = 2 * in[idx11 + idx3];
tr3 = 2 * in[idx11 + idx5];
cr2 = i1r + tr11 * tr2 + tr12 * tr3;
cr3 = i1r + tr12 * tr2 + tr11 * tr3;
ci5 = ti11 * ti5 + ti12 * ti4;
ci4 = ti12 * ti5 - ti11 * ti4;
out[out_off + idx1] = i1r + tr2 + tr3;
out[out_off + idx7] = cr2 - ci5;
out[out_off + idx8] = cr3 - ci4;
out[out_off + idx9] = cr3 + ci4;
out[out_off + idx10] = cr2 + ci5;
}
if (ido == 1)
return;
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
int widx4 = i - 1 + iw4;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
w4r = wtable_r[widx4 - 1];
w4i = wtable_r[widx4];
int idx15 = in_off + i;
int idx16 = in_off + ic;
int idx17 = out_off + i;
int iidx1 = idx15 + idx2;
int iidx2 = idx16 + idx3;
int iidx3 = idx15 + idx4;
int iidx4 = idx16 + idx5;
int iidx5 = idx15 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
ti5 = i3r + i2r;
ti2 = i3r - i2r;
ti4 = i5r + i4r;
ti3 = i5r - i4r;
tr5 = i3i - i2i;
tr2 = i3i + i2i;
tr4 = i5i - i4i;
tr3 = i5i + i4i;
cr2 = i1i + tr11 * tr2 + tr12 * tr3;
ci2 = i1r + tr11 * ti2 + tr12 * ti3;
cr3 = i1i + tr12 * tr2 + tr11 * tr3;
ci3 = i1r + tr12 * ti2 + tr11 * ti3;
cr5 = ti11 * tr5 + ti12 * tr4;
ci5 = ti11 * ti5 + ti12 * ti4;
cr4 = ti12 * tr5 - ti11 * tr4;
ci4 = ti12 * ti5 - ti11 * ti4;
dr3 = cr3 - ci4;
dr4 = cr3 + ci4;
di3 = ci3 + cr4;
di4 = ci3 - cr4;
dr5 = cr2 + ci5;
dr2 = cr2 - ci5;
di5 = ci2 - cr5;
di2 = ci2 + cr5;
int oidx1 = idx17 + idx1;
int oidx2 = idx17 + idx7;
int oidx3 = idx17 + idx8;
int oidx4 = idx17 + idx9;
int oidx5 = idx17 + idx10;
out[oidx1 - 1] = i1i + tr2 + tr3;
out[oidx1] = i1r + ti2 + ti3;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
out[oidx4 - 1] = w3r * dr4 - w3i * di4;
out[oidx4] = w3r * di4 + w3i * dr4;
out[oidx5 - 1] = w4r * dr5 - w4i * di5;
out[oidx5] = w4r * di5 + w4i * dr5;
}
}
}
/*---------------------------------------------------------
radfg: Real FFT's forward processing of general factor
-------------------------------------------------------- | FloatFFT::radfg | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
void radbg(final int ido, final int ip, final int l1, final int idl1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int idij, ipph, j2, ic, jc, lc, is;
float dc2, ai1, ai2, ar1, ar2, ds2, w1r, w1i;
int nbd;
float dcp, arg, dsp, ar1h, ar2h;
int iw1 = offset;
arg = TWO_PI / (float) ip;
dcp = (float)Math.cos(arg);
dsp = (float)Math.sin(arg);
nbd = (ido - 1) / 2;
ipph = (ip + 1) / 2;
int idx0 = ip * ido;
if (ido >= l1) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = k * idx0;
for (int i = 0; i < ido; i++) {
out[out_off + i + idx1] = in[in_off + i + idx2];
}
}
} else {
for (int i = 0; i < ido; i++) {
int idx1 = out_off + i;
int idx2 = in_off + i;
for (int k = 0; k < l1; k++) {
out[idx1 + k * ido] = in[idx2 + k * idx0];
}
}
}
int iidx0 = in_off + ido - 1;
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido;
int idx5 = idx4 * ip;
int iidx1 = iidx0 + idx3 + idx5 - ido;
int iidx2 = in_off + idx3 + idx5;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[out_off + idx4 + idx1] = i1r + i1r;
out[out_off + idx4 + idx2] = i2r + i2r;
}
}
if (ido != 1) {
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = 2 * j * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido + idx1;
int idx5 = k * ido + idx2;
int idx6 = k * ip * ido + idx3;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = out_off + i;
int idx8 = in_off + ic;
int idx9 = in_off + i;
int oidx1 = idx7 + idx4;
int oidx2 = idx7 + idx5;
int iidx1 = idx9 + idx6;
int iidx2 = idx8 + idx6 - ido;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
out[oidx1 - 1] = a1i + a2i;
out[oidx2 - 1] = a1i - a2i;
out[oidx1] = a1r - a2r;
out[oidx2] = a1r + a2r;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = 2 * j * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = out_off + i;
int idx8 = in_off + ic;
int idx9 = in_off + i;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido + idx1;
int idx5 = k * ido + idx2;
int idx6 = k * ip * ido + idx3;
int oidx1 = idx7 + idx4;
int oidx2 = idx7 + idx5;
int iidx1 = idx9 + idx6;
int iidx2 = idx8 + idx6 - ido;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
out[oidx1 - 1] = a1i + a2i;
out[oidx2 - 1] = a1i - a2i;
out[oidx1] = a1r - a2r;
out[oidx2] = a1r + a2r;
}
}
}
}
}
ar1 = 1;
ai1 = 0;
int idx01 = (ip - 1) * idl1;
for (int l = 1; l < ipph; l++) {
lc = ip - l;
ar1h = dcp * ar1 - dsp * ai1;
ai1 = dcp * ai1 + dsp * ar1;
ar1 = ar1h;
int idx1 = l * idl1;
int idx2 = lc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx3 = in_off + ik;
int idx4 = out_off + ik;
in[idx3 + idx1] = out[idx4] + ar1 * out[idx4 + idl1];
in[idx3 + idx2] = ai1 * out[idx4 + idx01];
}
dc2 = ar1;
ds2 = ai1;
ar2 = ar1;
ai2 = ai1;
for (int j = 2; j < ipph; j++) {
jc = ip - j;
ar2h = dc2 * ar2 - ds2 * ai2;
ai2 = dc2 * ai2 + ds2 * ar2;
ar2 = ar2h;
int idx5 = j * idl1;
int idx6 = jc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx7 = in_off + ik;
int idx8 = out_off + ik;
in[idx7 + idx1] += ar2 * out[idx8 + idx5];
in[idx7 + idx2] += ai2 * out[idx8 + idx6];
}
}
}
for (int j = 1; j < ipph; j++) {
int idx1 = j * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx2 = out_off + ik;
out[idx2] += out[idx2 + idx1];
}
}
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int oidx1 = out_off + idx3;
int iidx1 = in_off + idx3 + idx1;
int iidx2 = in_off + idx3 + idx2;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1 + idx1] = i1r - i2r;
out[oidx1 + idx2] = i1r + i2r;
}
}
if (ido == 1)
return;
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
for (int i = 2; i < ido; i += 2) {
int idx4 = out_off + i;
int idx5 = in_off + i;
int oidx1 = idx4 + idx3 + idx1;
int oidx2 = idx4 + idx3 + idx2;
int iidx1 = idx5 + idx3 + idx1;
int iidx2 = idx5 + idx3 + idx2;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
out[oidx1 - 1] = i1i - i2r;
out[oidx2 - 1] = i1i + i2r;
out[oidx1] = i1r + i2i;
out[oidx2] = i1r - i2i;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int i = 2; i < ido; i += 2) {
int idx4 = out_off + i;
int idx5 = in_off + i;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int oidx1 = idx4 + idx3 + idx1;
int oidx2 = idx4 + idx3 + idx2;
int iidx1 = idx5 + idx3 + idx1;
int iidx2 = idx5 + idx3 + idx2;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
out[oidx1 - 1] = i1i - i2r;
out[oidx2 - 1] = i1i + i2r;
out[oidx1] = i1r + i2i;
out[oidx2] = i1r - i2i;
}
}
}
}
System.arraycopy(out, out_off, in, in_off, idl1);
for (int j = 1; j < ip; j++) {
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx2 = k * ido + idx1;
in[in_off + idx2] = out[out_off + idx2];
}
}
if (nbd <= l1) {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
idij = is - 1;
int idx1 = j * l1 * ido;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
int idx4 = in_off + i;
int idx5 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int iidx1 = idx4 + idx3;
int oidx1 = idx5 + idx3;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
in[iidx1 - 1] = w1r * o1i - w1i * o1r;
in[iidx1] = w1r * o1r + w1i * o1i;
}
}
}
} else {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
idij = is - 1;
int idx3 = k * ido + idx1;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
int idx4 = in_off + i;
int idx5 = out_off + i;
int iidx1 = idx4 + idx3;
int oidx1 = idx5 + idx3;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
in[iidx1 - 1] = w1r * o1i - w1i * o1r;
in[iidx1] = w1r * o1r + w1i * o1i;
}
}
}
}
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. This method computes the full real inverse transform, i.e. you will get
the same result as from <code>complexInverse</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
public void realInverseFull(final float[] a, final int offa, boolean scale) {
final int twon = 2 * n;
switch (plan) {
case SPLIT_RADIX:
realInverse2(a, offa, scale);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n / 2 > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
Future<?>[] futures = new Future[nthreads];
int k = n / 2 / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n / 2 : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
int idx1, idx2;
for (int k = firstIdx; k < lastIdx; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
int idx1, idx2;
for (int k = 0; k < n / 2; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
a[offa + n] = -a[offa + 1];
a[offa + 1] = 0;
break;
case MIXED_RADIX:
rfftf(a, offa);
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
} else {
m = (n + 1) / 2;
}
for (int k = 1; k < m; k++) {
int idx1 = offa + 2 * k;
int idx2 = offa + twon - 2 * k;
a[idx1] = -a[idx1];
a[idx2 + 1] = -a[idx1];
a[idx2] = a[idx1 - 1];
}
for (int k = 1; k < n; k++) {
int idx = offa + n - k;
float tmp = a[idx + 1];
a[idx + 1] = a[idx];
a[idx] = tmp;
}
a[offa + 1] = 0;
break;
case BLUESTEIN:
bluestein_real_full(a, offa, 1);
if (scale) {
scale(n, a, offa, true);
}
break;
}
}
private void realInverse2(float[] a, int offa, boolean scale) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
float xi;
if (n > 4) {
cftfsub(n, a, offa, ip, nw, w);
rftbsub(n, a, offa, nc, w, nw);
} else if (n == 4) {
cftbsub(n, a, offa, ip, nw, w);
}
xi = a[offa] - a[offa + 1];
a[offa] += a[offa + 1];
a[offa + 1] = xi;
if (scale) {
scale(n, a, offa, false);
}
break;
case MIXED_RADIX:
rfftf(a, offa);
for (int k = n - 1; k >= 2; k--) {
int idx = offa + k;
float tmp = a[idx];
a[idx] = a[idx - 1];
a[idx - 1] = tmp;
}
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
for (int i = 1; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
} else {
m = (n - 1) / 2;
for (int i = 0; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
}
break;
case BLUESTEIN:
bluestein_real_inverse2(a, offa);
if (scale) {
scale(n, a, offa, false);
}
break;
}
}
private static int getReminder(int n, int[] factors) {
int reminder = n;
if (n <= 0) {
throw new IllegalArgumentException("n must be positive integer");
}
for (int i = 0; i < factors.length && reminder != 1; i++) {
int factor = factors[i];
while ((reminder % factor) == 0) {
reminder /= factor;
}
}
return reminder;
}
/* -------- initializing routines --------
/*---------------------------------------------------------
cffti: initialization of Complex FFT
--------------------------------------------------------
void cffti(int n, int offw) {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[offw + nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[offw + idx + 1] = wtable[offw + idx];
}
wtable[offw + 2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[offw + fourn] = n;
wtable[offw + 1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[offw + k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[offw + i - 1 + twon] = 1;
wtable[offw + i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[offw + idx - 1] = (float)Math.cos(arg);
wtable[offw + idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[offw + idx1 - 1] = wtable[offw + idx2 - 1];
wtable[offw + idx1] = wtable[offw + idx2];
}
}
l1 = l2;
}
}
void cffti() {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[idx + 1] = wtable[idx];
}
wtable[2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[fourn] = n;
wtable[1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[i - 1 + twon] = 1;
wtable[i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[idx - 1] = (float)Math.cos(arg);
wtable[idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[idx1 - 1] = wtable[idx2 - 1];
wtable[idx1] = wtable[idx2];
}
}
l1 = l2;
}
}
void rffti() {
if (n == 1)
return;
final int twon = 2 * n;
float argh;
int ntry = 0, i, j;
float argld;
int k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, is, nq, nr;
float arg;
int ido, ipm;
int nfm1;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
++j;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
++nf;
wtable_r[nf + 1 + twon] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + twon;
wtable_r[idx + 1] = wtable_r[idx];
}
wtable_r[2 + twon] = 2;
}
} while (nl != 1);
break;
}
wtable_r[twon] = n;
wtable_r[1 + twon] = nf;
argh = TWO_PI / (float) (n);
is = 0;
nfm1 = nf - 1;
l1 = 1;
if (nfm1 == 0)
return;
for (k1 = 1; k1 <= nfm1; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
ipm = ip - 1;
for (j = 1; j <= ipm; ++j) {
ld += l1;
i = is;
argld = (float) ld * argh;
fi = 0;
for (ii = 3; ii <= ido; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + n;
wtable_r[idx - 2] = (float)Math.cos(arg);
wtable_r[idx - 1] = (float)Math.sin(arg);
}
is += ido;
}
l1 = l2;
}
}
private void bluesteini() {
int k = 0;
float arg;
float pi_n = PI / n;
bk1[0] = 1;
bk1[1] = 0;
for (int i = 1; i < n; i++) {
k += 2 * i - 1;
if (k >= 2 * n)
k -= 2 * n;
arg = pi_n * k;
bk1[2 * i] = (float)Math.cos(arg);
bk1[2 * i + 1] = (float)Math.sin(arg);
}
float scale = (float)(1.0 / nBluestein);
bk2[0] = bk1[0] * scale;
bk2[1] = bk1[1] * scale;
for (int i = 2; i < 2 * n; i += 2) {
bk2[i] = bk1[i] * scale;
bk2[i + 1] = bk1[i + 1] * scale;
bk2[2 * nBluestein - i] = bk2[i];
bk2[2 * nBluestein - i + 1] = bk2[i + 1];
}
cftbsub(2 * nBluestein, bk2, 0, ip, nw, w);
}
private void makewt(int nw) {
int j, nwh, nw0, nw1;
float delta, wn4r, wk1r, wk1i, wk3r, wk3i;
float delta2, deltaj, deltaj3;
ip[0] = nw;
ip[1] = 1;
if (nw > 2) {
nwh = nw >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nwh);
delta2 = delta * 2;
wn4r = (float)Math.cos(delta * nwh);
w[0] = 1;
w[1] = wn4r;
if (nwh == 4) {
w[2] = (float)Math.cos(delta2);
w[3] = (float)Math.sin(delta2);
} else if (nwh > 4) {
makeipt(nw);
w[2] = (float)(0.5 / Math.cos(delta2));
w[3] = (float)(0.5 / Math.cos(delta * 6));
for (j = 4; j < nwh; j += 4) {
deltaj = delta * j;
deltaj3 = 3 * deltaj;
w[j] = (float)Math.cos(deltaj);
w[j + 1] = (float)Math.sin(deltaj);
w[j + 2] = (float)Math.cos(deltaj3);
w[j + 3] = (float)-Math.sin(deltaj3);
}
}
nw0 = 0;
while (nwh > 2) {
nw1 = nw0 + nwh;
nwh >>= 1;
w[nw1] = 1;
w[nw1 + 1] = wn4r;
if (nwh == 4) {
wk1r = w[nw0 + 4];
wk1i = w[nw0 + 5];
w[nw1 + 2] = wk1r;
w[nw1 + 3] = wk1i;
} else if (nwh > 4) {
wk1r = w[nw0 + 4];
wk3r = w[nw0 + 6];
w[nw1 + 2] = (float)(0.5 / wk1r);
w[nw1 + 3] = (float)(0.5 / wk3r);
for (j = 4; j < nwh; j += 4) {
int idx1 = nw0 + 2 * j;
int idx2 = nw1 + j;
wk1r = w[idx1];
wk1i = w[idx1 + 1];
wk3r = w[idx1 + 2];
wk3i = w[idx1 + 3];
w[idx2] = wk1r;
w[idx2 + 1] = wk1i;
w[idx2 + 2] = wk3r;
w[idx2 + 3] = wk3i;
}
}
nw0 = nw1;
}
}
}
private void makeipt(int nw) {
int j, l, m, m2, p, q;
ip[2] = 0;
ip[3] = 16;
m = 2;
for (l = nw; l > 32; l >>= 2) {
m2 = m << 1;
q = m2 << 3;
for (j = m; j < m2; j++) {
p = ip[j] << 2;
ip[m + j] = p;
ip[m2 + j] = p + q;
}
m = m2;
}
}
private void makect(int nc, float[] c, int startc) {
int j, nch;
float delta, deltaj;
ip[1] = nc;
if (nc > 1) {
nch = nc >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nch);
c[startc] = (float)Math.cos(delta * nch);
c[startc + nch] = (float)(0.5 * c[startc]);
for (j = 1; j < nch; j++) {
deltaj = delta * j;
c[startc + j] = (float)(0.5 * Math.cos(deltaj));
c[startc + nc - j] = (float)(0.5 * Math.sin(deltaj));
}
}
}
private void bluestein_complex(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_full(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_forward(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] + bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = -bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] + bk1[n] * ak[n];
}
}
private void bluestein_real_inverse(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
if (n % 2 == 0) {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n] = a[offa + 1] * bk1[n];
ak[n + 1] = a[offa + 1] * bk1[n + 1];
for (int i = n / 2 + 1; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
} else {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n - 1] = a[offa + n - 1] * bk1[n - 1] - a[offa + 1] * bk1[n];
ak[n] = a[offa + n - 1] * bk1[n] + a[offa + 1] * bk1[n - 1];
ak[n + 1] = a[offa + n - 1] * bk1[n + 1] + a[offa + 1] * bk1[n + 2];
ak[n + 2] = a[offa + n - 1] * bk1[n + 2] - a[offa + 1] * bk1[n + 1];
for (int i = (n - 1) / 2 + 2; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
}
private void bluestein_real_inverse2(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] - bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] - bk1[n] * ak[n];
}
}
/*---------------------------------------------------------
rfftf1: further processing of Real forward FFT
--------------------------------------------------------
void rfftf(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, kh, nf, ip, iw, ido, idl1;
final float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 1;
l2 = n;
iw = twon - 1;
for (int k1 = 1; k1 <= nf; ++k1) {
kh = nf - k1;
ip = (int) wtable_r[kh + 2 + twon];
l1 = l2 / ip;
ido = n / l2;
idl1 = ido * l1;
iw -= (ip - 1) * ido;
na = 1 - na;
switch (ip) {
case 2:
if (na == 0) {
radf2(ido, l1, a, offa, ch, 0, iw);
} else {
radf2(ido, l1, ch, 0, a, offa, iw);
}
break;
case 3:
if (na == 0) {
radf3(ido, l1, a, offa, ch, 0, iw);
} else {
radf3(ido, l1, ch, 0, a, offa, iw);
}
break;
case 4:
if (na == 0) {
radf4(ido, l1, a, offa, ch, 0, iw);
} else {
radf4(ido, l1, ch, 0, a, offa, iw);
}
break;
case 5:
if (na == 0) {
radf5(ido, l1, a, offa, ch, 0, iw);
} else {
radf5(ido, l1, ch, 0, a, offa, iw);
}
break;
default:
if (ido == 1)
na = 1 - na;
if (na == 0) {
radfg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
na = 1;
} else {
radfg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
na = 0;
}
break;
}
l2 = l1;
}
if (na == 1)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*---------------------------------------------------------
rfftb1: further processing of Real backward FFT
--------------------------------------------------------
void rfftb(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, nf, ip, iw, ido, idl1;
float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 0;
l1 = 1;
iw = n;
for (int k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
l2 = ip * l1;
ido = n / l2;
idl1 = ido * l1;
switch (ip) {
case 2:
if (na == 0) {
radb2(ido, l1, a, offa, ch, 0, iw);
} else {
radb2(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
radb3(ido, l1, a, offa, ch, 0, iw);
} else {
radb3(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 4:
if (na == 0) {
radb4(ido, l1, a, offa, ch, 0, iw);
} else {
radb4(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
radb5(ido, l1, a, offa, ch, 0, iw);
} else {
radb5(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
default:
if (na == 0) {
radbg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
} else {
radbg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
}
if (ido == 1)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * ido;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*-------------------------------------------------
radf2: Real FFT's forward processing of factor 2
-------------------------------------------------
void radf2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic, idx0, idx1, idx2, idx3, idx4;
float t1i, t1r, w1r, w1i;
int iw1;
iw1 = offset;
idx0 = l1 * ido;
idx1 = 2 * ido;
for (int k = 0; k < l1; k++) {
int oidx1 = out_off + k * idx1;
int oidx2 = oidx1 + idx1 - 1;
int iidx1 = in_off + k * ido;
int iidx2 = iidx1 + idx0;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx2] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
idx2 = 2 * idx1;
idx3 = idx2 + ido;
idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int oidx1 = out_off + i + idx2;
int oidx2 = out_off + ic + idx3;
int iidx1 = in_off + i + idx1;
int iidx2 = in_off + i + idx4;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
t1r = w1r * a2i + w1i * a2r;
t1i = w1r * a2r - w1i * a2i;
out[oidx1] = a1r + t1i;
out[oidx1 - 1] = a1i + t1r;
out[oidx2] = t1i - a1r;
out[oidx2 - 1] = a1i - t1r;
}
}
if (ido % 2 == 1)
return;
}
idx2 = 2 * idx1;
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
int oidx1 = out_off + idx2 + ido;
int iidx1 = in_off + ido - 1 + idx1;
out[oidx1] = -in[iidx1 + idx0];
out[oidx1 - 1] = in[iidx1];
}
}
/*-------------------------------------------------
radb2: Real FFT's backward processing of factor 2
-------------------------------------------------
void radb2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic;
float t1i, t1r, w1r, w1i;
int iw1 = offset;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int oidx1 = out_off + idx1;
int iidx1 = in_off + idx2;
int iidx2 = in_off + ido - 1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx1 + idx0] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx5 = i - 1 + iw1;
int idx6 = out_off + i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
w1r = wtable_r[idx5 - 1];
w1i = wtable_r[idx5];
int iidx1 = idx7 + idx2;
int iidx2 = idx8 + idx3;
int oidx1 = idx6 + idx1;
int oidx2 = idx6 + idx4;
t1r = in[iidx1 - 1] - in[iidx2 - 1];
t1i = in[iidx1] + in[iidx2];
float i1i = in[iidx1];
float i1r = in[iidx1 - 1];
float i2i = in[iidx2];
float i2r = in[iidx2 - 1];
out[oidx1 - 1] = i1r + i2r;
out[oidx1] = i1i - i2i;
out[oidx2 - 1] = w1r * t1r - w1i * t1i;
out[oidx2] = w1r * t1i + w1i * t1r;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int oidx1 = out_off + ido - 1 + idx1;
int iidx1 = in_off + idx2 + ido;
out[oidx1] = 2 * in[iidx1 - 1];
out[oidx1 + idx0] = -2 * in[iidx1];
}
}
/*-------------------------------------------------
radf3: Real FFT's forward processing of factor 3
-------------------------------------------------
void radf3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, di2, di3, cr2, dr2, dr3, ti2, ti3, tr2, tr3, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx3 = 2 * idx0;
int idx4 = (3 * k + 1) * ido;
int iidx1 = in_off + idx1;
int iidx2 = iidx1 + idx0;
int iidx3 = iidx1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
float i3r = in[iidx3];
cr2 = i2r + i3r;
out[out_off + 3 * idx1] = i1r + cr2;
out[out_off + idx4 + ido] = taui * (i3r - i2r);
out[out_off + ido - 1 + idx4] = i1r + taur * cr2;
}
if (ido == 1)
return;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int idx4 = 3 * idx3;
int idx5 = idx3 + idx0;
int idx6 = idx5 + idx0;
int idx7 = idx4 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx3;
int iidx2 = idx9 + idx5;
int iidx3 = idx9 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
cr2 = dr2 + dr3;
ci2 = di2 + di3;
tr2 = i1i + taur * cr2;
ti2 = i1r + taur * ci2;
tr3 = taui * (di2 - di3);
ti3 = taui * (dr3 - dr2);
int oidx1 = idx10 + idx4;
int oidx2 = idx11 + idx7;
int oidx3 = idx10 + idx8;
out[oidx1 - 1] = i1i + cr2;
out[oidx1] = i1r + ci2;
out[oidx2 - 1] = tr2 - tr3;
out[oidx2] = ti3 - ti2;
out[oidx3 - 1] = tr2 + tr3;
out[oidx3] = ti2 + ti3;
}
}
}
/*-------------------------------------------------
radb3: Real FFT's backward processing of factor 3
-------------------------------------------------
void radb3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, ci3, di2, di3, cr2, cr3, dr2, dr3, ti2, tr2, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int iidx1 = in_off + 3 * idx1;
int iidx2 = iidx1 + 2 * ido;
float i1i = in[iidx1];
tr2 = 2 * in[iidx2 - 1];
cr2 = i1i + taur * tr2;
ci3 = 2 * taui * in[iidx2];
out[out_off + idx1] = i1i + tr2;
out[out_off + (k + l1) * ido] = cr2 - ci3;
out[out_off + (k + 2 * l1) * ido] = cr2 + ci3;
}
if (ido == 1)
return;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 3 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx1 + idx0;
int idx6 = idx5 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
int idx9 = out_off + i;
int iidx1 = idx7 + idx2;
int iidx2 = idx7 + idx4;
int iidx3 = idx8 + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
tr2 = i2i + i3i;
cr2 = i1i + taur * tr2;
ti2 = i2r - i3r;
ci2 = i1r + taur * ti2;
cr3 = taui * (i2i - i3i);
ci3 = taui * (i2r + i3r);
dr2 = cr2 - ci3;
dr3 = cr2 + ci3;
di2 = ci2 + cr3;
di3 = ci2 - cr3;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int oidx1 = idx9 + idx1;
int oidx2 = idx9 + idx5;
int oidx3 = idx9 + idx6;
out[oidx1 - 1] = i1i + tr2;
out[oidx1] = i1r + ti2;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
}
}
}
/*-------------------------------------------------
radf4: Real FFT's forward processing of factor 4
-------------------------------------------------
void radf4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float hsqt2 = 0.707106781186547572737310929369414225f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = offset + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx3];
float i3r = in[in_off + idx4];
float i4r = in[in_off + idx5];
tr1 = i2r + i4r;
tr2 = i1r + i3r;
int oidx1 = out_off + idx2;
int oidx2 = out_off + idx6 + ido;
out[oidx1] = tr1 + tr2;
out[oidx2 - 1 + ido + ido] = tr2 - tr1;
out[oidx2 - 1] = i1r - i3r;
out[oidx2] = i4r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx1;
int iidx2 = idx9 + idx2;
int iidx3 = idx9 + idx3;
int iidx4 = idx9 + idx4;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
cr2 = w1r * i2i + w1i * i2r;
ci2 = w1r * i2r - w1i * i2i;
cr3 = w2r * i3i + w2i * i3r;
ci3 = w2r * i3r - w2i * i3i;
cr4 = w3r * i4i + w3i * i4r;
ci4 = w3r * i4r - w3i * i4i;
tr1 = cr2 + cr4;
tr4 = cr4 - cr2;
ti1 = ci2 + ci4;
ti4 = ci2 - ci4;
ti2 = i1r + ci3;
ti3 = i1r - ci3;
tr2 = i1i + cr3;
tr3 = i1i - cr3;
int oidx1 = idx10 + idx5;
int oidx2 = idx11 + idx6;
int oidx3 = idx10 + idx7;
int oidx4 = idx11 + idx8;
out[oidx1 - 1] = tr1 + tr2;
out[oidx4 - 1] = tr2 - tr1;
out[oidx1] = ti1 + ti2;
out[oidx4] = ti1 - ti2;
out[oidx3 - 1] = ti4 + tr3;
out[oidx2 - 1] = tr3 - ti4;
out[oidx3] = tr4 + ti3;
out[oidx2] = tr4 - ti3;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1i = in[idx9 - 1 + idx1];
float i2i = in[idx9 - 1 + idx3];
float i3i = in[idx9 - 1 + idx4];
float i4i = in[idx9 - 1 + idx5];
ti1 = -hsqt2 * (i2i + i4i);
tr1 = hsqt2 * (i2i - i4i);
out[idx10 - 1 + idx2] = tr1 + i1i;
out[idx10 - 1 + idx7] = i1i - tr1;
out[out_off + idx6] = ti1 - i3i;
out[out_off + idx8] = ti1 + i3i;
}
}
/*-------------------------------------------------
radb4: Real FFT's backward processing of factor 4
-------------------------------------------------
void radb4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float sqrt2 = 1.41421356237309514547462185873882845f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4;
float ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
float i1r = in[in_off + idx2];
float i2r = in[in_off + idx7];
float i3r = in[in_off + ido - 1 + idx8];
float i4r = in[in_off + ido - 1 + idx6];
tr1 = i1r - i3r;
tr2 = i1r + i3r;
tr3 = i4r + i4r;
tr4 = i2r + i2r;
out[out_off + idx1] = tr2 + tr3;
out[out_off + idx3] = tr1 - tr4;
out[out_off + idx4] = tr2 - tr3;
out[out_off + idx5] = tr1 + tr4;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx12 = in_off + i;
int idx13 = in_off + ic;
int idx14 = out_off + i;
int iidx1 = idx12 + idx5;
int iidx2 = idx13 + idx6;
int iidx3 = idx12 + idx7;
int iidx4 = idx13 + idx8;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
ti1 = i1r + i4r;
ti2 = i1r - i4r;
ti3 = i3r - i2r;
tr4 = i3r + i2r;
tr1 = i1i - i4i;
tr2 = i1i + i4i;
ti4 = i3i - i2i;
tr3 = i3i + i2i;
cr3 = tr2 - tr3;
ci3 = ti2 - ti3;
cr2 = tr1 - tr4;
cr4 = tr1 + tr4;
ci2 = ti1 + ti4;
ci4 = ti1 - ti4;
int oidx1 = idx14 + idx1;
int oidx2 = idx14 + idx2;
int oidx3 = idx14 + idx3;
int oidx4 = idx14 + idx4;
out[oidx1 - 1] = tr2 + tr3;
out[oidx1] = ti2 + ti3;
out[oidx2 - 1] = w1r * cr2 - w1i * ci2;
out[oidx2] = w1r * ci2 + w1i * cr2;
out[oidx3 - 1] = w2r * cr3 - w2i * ci3;
out[oidx3] = w2r * ci3 + w2i * cr3;
out[oidx4 - 1] = w3r * cr4 - w3i * ci4;
out[oidx4] = w3r * ci4 + w3i * cr4;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1r = in[idx9 - 1 + idx2];
float i2r = in[idx9 - 1 + idx7];
float i3r = in[in_off + idx6];
float i4r = in[in_off + idx8];
ti1 = i3r + i4r;
ti2 = i4r - i3r;
tr1 = i1r - i2r;
tr2 = i1r + i2r;
out[idx10 - 1 + idx1] = tr2 + tr2;
out[idx10 - 1 + idx3] = sqrt2 * (tr1 - ti1);
out[idx10 - 1 + idx4] = ti2 + ti2;
out[idx10 - 1 + idx5] = -sqrt2 * (tr1 + ti1);
}
}
/*-------------------------------------------------
radf5: Real FFT's forward processing of factor 5
-------------------------------------------------
void radf5(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float tr11 = 0.309016994374947451262869435595348477f;
final float ti11 = 0.951056516295153531181938433292089030f;
final float tr12 = -0.809016994374947340240566973079694435f;
final float ti12 = 0.587785252292473248125759255344746634f;
int i, ic;
float ci2, di2, ci4, ci5, di3, di4, di5, ci3, cr2, cr3, dr2, dr3, dr4, dr5, cr5, cr4, ti2, ti3, ti5, ti4, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
int iw1, iw2, iw3, iw4;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
iw4 = iw3 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
int idx11 = out_off + ido - 1;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx7];
float i3r = in[in_off + idx8];
float i4r = in[in_off + idx9];
float i5r = in[in_off + idx10];
cr2 = i5r + i2r;
ci5 = i5r - i2r;
cr3 = i4r + i3r;
ci4 = i4r - i3r;
out[out_off + idx2] = i1r + cr2 + cr3;
out[idx11 + idx3] = i1r + tr11 * cr2 + tr12 * cr3;
out[out_off + idx4] = ti11 * ci5 + ti12 * ci4;
out[idx11 + idx5] = i1r + tr12 * cr2 + tr11 * cr3;
out[out_off + idx6] = ti12 * ci5 - ti11 * ci4;
}
if (ido == 1)
return;
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
for (i = 2; i < ido; i += 2) {
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
int widx4 = i - 1 + iw4;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
w4r = wtable_r[widx4 - 1];
w4i = wtable_r[widx4];
ic = ido - i;
int idx15 = in_off + i;
int idx16 = out_off + i;
int idx17 = out_off + ic;
int iidx1 = idx15 + idx1;
int iidx2 = idx15 + idx7;
int iidx3 = idx15 + idx8;
int iidx4 = idx15 + idx9;
int iidx5 = idx15 + idx10;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
dr4 = w3r * i4i + w3i * i4r;
di4 = w3r * i4r - w3i * i4i;
dr5 = w4r * i5i + w4i * i5r;
di5 = w4r * i5r - w4i * i5i;
cr2 = dr2 + dr5;
ci5 = dr5 - dr2;
cr5 = di2 - di5;
ci2 = di2 + di5;
cr3 = dr3 + dr4;
ci4 = dr4 - dr3;
cr4 = di3 - di4;
ci3 = di3 + di4;
tr2 = i1i + tr11 * cr2 + tr12 * cr3;
ti2 = i1r + tr11 * ci2 + tr12 * ci3;
tr3 = i1i + tr12 * cr2 + tr11 * cr3;
ti3 = i1r + tr12 * ci2 + tr11 * ci3;
tr5 = ti11 * cr5 + ti12 * cr4;
ti5 = ti11 * ci5 + ti12 * ci4;
tr4 = ti12 * cr5 - ti11 * cr4;
ti4 = ti12 * ci5 - ti11 * ci4;
int oidx1 = idx16 + idx2;
int oidx2 = idx17 + idx3;
int oidx3 = idx16 + idx4;
int oidx4 = idx17 + idx5;
int oidx5 = idx16 + idx6;
out[oidx1 - 1] = i1i + cr2 + cr3;
out[oidx1] = i1r + ci2 + ci3;
out[oidx3 - 1] = tr2 + tr5;
out[oidx2 - 1] = tr2 - tr5;
out[oidx3] = ti2 + ti5;
out[oidx2] = ti5 - ti2;
out[oidx5 - 1] = tr3 + tr4;
out[oidx4 - 1] = tr3 - tr4;
out[oidx5] = ti3 + ti4;
out[oidx4] = ti4 - ti3;
}
}
}
/*-------------------------------------------------
radb5: Real FFT's backward processing of factor 5
-------------------------------------------------
void radb5(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float tr11 = 0.309016994374947451262869435595348477f;
final float ti11 = 0.951056516295153531181938433292089030f;
final float tr12 = -0.809016994374947340240566973079694435f;
final float ti12 = 0.587785252292473248125759255344746634f;
int i, ic;
float ci2, ci3, ci4, ci5, di3, di4, di5, di2, cr2, cr3, cr5, cr4, ti2, ti3, ti4, ti5, dr3, dr4, dr5, dr2, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
int iw1, iw2, iw3, iw4;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
iw4 = iw3 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
int idx11 = in_off + ido - 1;
float i1r = in[in_off + idx2];
ti5 = 2 * in[in_off + idx4];
ti4 = 2 * in[in_off + idx6];
tr2 = 2 * in[idx11 + idx3];
tr3 = 2 * in[idx11 + idx5];
cr2 = i1r + tr11 * tr2 + tr12 * tr3;
cr3 = i1r + tr12 * tr2 + tr11 * tr3;
ci5 = ti11 * ti5 + ti12 * ti4;
ci4 = ti12 * ti5 - ti11 * ti4;
out[out_off + idx1] = i1r + tr2 + tr3;
out[out_off + idx7] = cr2 - ci5;
out[out_off + idx8] = cr3 - ci4;
out[out_off + idx9] = cr3 + ci4;
out[out_off + idx10] = cr2 + ci5;
}
if (ido == 1)
return;
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
int widx4 = i - 1 + iw4;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
w4r = wtable_r[widx4 - 1];
w4i = wtable_r[widx4];
int idx15 = in_off + i;
int idx16 = in_off + ic;
int idx17 = out_off + i;
int iidx1 = idx15 + idx2;
int iidx2 = idx16 + idx3;
int iidx3 = idx15 + idx4;
int iidx4 = idx16 + idx5;
int iidx5 = idx15 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
ti5 = i3r + i2r;
ti2 = i3r - i2r;
ti4 = i5r + i4r;
ti3 = i5r - i4r;
tr5 = i3i - i2i;
tr2 = i3i + i2i;
tr4 = i5i - i4i;
tr3 = i5i + i4i;
cr2 = i1i + tr11 * tr2 + tr12 * tr3;
ci2 = i1r + tr11 * ti2 + tr12 * ti3;
cr3 = i1i + tr12 * tr2 + tr11 * tr3;
ci3 = i1r + tr12 * ti2 + tr11 * ti3;
cr5 = ti11 * tr5 + ti12 * tr4;
ci5 = ti11 * ti5 + ti12 * ti4;
cr4 = ti12 * tr5 - ti11 * tr4;
ci4 = ti12 * ti5 - ti11 * ti4;
dr3 = cr3 - ci4;
dr4 = cr3 + ci4;
di3 = ci3 + cr4;
di4 = ci3 - cr4;
dr5 = cr2 + ci5;
dr2 = cr2 - ci5;
di5 = ci2 - cr5;
di2 = ci2 + cr5;
int oidx1 = idx17 + idx1;
int oidx2 = idx17 + idx7;
int oidx3 = idx17 + idx8;
int oidx4 = idx17 + idx9;
int oidx5 = idx17 + idx10;
out[oidx1 - 1] = i1i + tr2 + tr3;
out[oidx1] = i1r + ti2 + ti3;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
out[oidx4 - 1] = w3r * dr4 - w3i * di4;
out[oidx4] = w3r * di4 + w3i * dr4;
out[oidx5 - 1] = w4r * dr5 - w4i * di5;
out[oidx5] = w4r * di5 + w4i * dr5;
}
}
}
/*---------------------------------------------------------
radfg: Real FFT's forward processing of general factor
--------------------------------------------------------
void radfg(final int ido, final int ip, final int l1, final int idl1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int idij, ipph, j2, ic, jc, lc, is, nbd;
float dc2, ai1, ai2, ar1, ar2, ds2, dcp, arg, dsp, ar1h, ar2h, w1r, w1i;
int iw1 = offset;
arg = TWO_PI / (float) ip;
dcp = (float)Math.cos(arg);
dsp = (float)Math.sin(arg);
ipph = (ip + 1) / 2;
nbd = (ido - 1) / 2;
if (ido != 1) {
if (idl1 >= 0) System.arraycopy(in, in_off, out, out_off, idl1);
for (int j = 1; j < ip; j++) {
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx2 = k * ido + idx1;
out[out_off + idx2] = in[in_off + idx2];
}
}
if (nbd <= l1) {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
idij = is - 1;
int idx1 = j * l1 * ido;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
int idx4 = in_off + i;
int idx5 = out_off + i;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int oidx1 = idx5 + idx3;
int iidx1 = idx4 + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
out[oidx1 - 1] = w1r * i1i + w1i * i1r;
out[oidx1] = w1r * i1r - w1i * i1i;
}
}
}
} else {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
idij = is - 1;
int idx3 = k * ido + idx1;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
int oidx1 = out_off + i + idx3;
int iidx1 = in_off + i + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
out[oidx1 - 1] = w1r * i1i + w1i * i1r;
out[oidx1] = w1r * i1r - w1i * i1i;
}
}
}
}
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
for (int i = 2; i < ido; i += 2) {
int idx5 = in_off + i;
int idx6 = out_off + i;
int iidx1 = idx5 + idx3;
int iidx2 = idx5 + idx4;
int oidx1 = idx6 + idx3;
int oidx2 = idx6 + idx4;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx1] = o1r + o2r;
in[iidx2 - 1] = o1r - o2r;
in[iidx2] = o2i - o1i;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int i = 2; i < ido; i += 2) {
int idx5 = in_off + i;
int idx6 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
int iidx1 = idx5 + idx3;
int iidx2 = idx5 + idx4;
int oidx1 = idx6 + idx3;
int oidx2 = idx6 + idx4;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx1] = o1r + o2r;
in[iidx2 - 1] = o1r - o2r;
in[iidx2] = o2i - o1i;
}
}
}
}
} else {
System.arraycopy(out, out_off, in, in_off, idl1);
}
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
int oidx1 = out_off + idx3;
int oidx2 = out_off + idx4;
float o1r = out[oidx1];
float o2r = out[oidx2];
in[in_off + idx3] = o1r + o2r;
in[in_off + idx4] = o2r - o1r;
}
}
ar1 = 1;
ai1 = 0;
int idx0 = (ip - 1) * idl1;
for (int l = 1; l < ipph; l++) {
lc = ip - l;
ar1h = dcp * ar1 - dsp * ai1;
ai1 = dcp * ai1 + dsp * ar1;
ar1 = ar1h;
int idx1 = l * idl1;
int idx2 = lc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx3 = out_off + ik;
int idx4 = in_off + ik;
out[idx3 + idx1] = in[idx4] + ar1 * in[idx4 + idl1];
out[idx3 + idx2] = ai1 * in[idx4 + idx0];
}
dc2 = ar1;
ds2 = ai1;
ar2 = ar1;
ai2 = ai1;
for (int j = 2; j < ipph; j++) {
jc = ip - j;
ar2h = dc2 * ar2 - ds2 * ai2;
ai2 = dc2 * ai2 + ds2 * ar2;
ar2 = ar2h;
int idx3 = j * idl1;
int idx4 = jc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx5 = out_off + ik;
int idx6 = in_off + ik;
out[idx5 + idx1] += ar2 * in[idx6 + idx3];
out[idx5 + idx2] += ai2 * in[idx6 + idx4];
}
}
}
for (int j = 1; j < ipph; j++) {
int idx1 = j * idl1;
for (int ik = 0; ik < idl1; ik++) {
out[out_off + ik] += in[in_off + ik + idx1];
}
}
if (ido >= l1) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = idx1 * ip;
for (int i = 0; i < ido; i++) {
in[in_off + i + idx2] = out[out_off + i + idx1];
}
}
} else {
for (int i = 0; i < ido; i++) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
in[in_off + i + idx1 * ip] = out[out_off + i + idx1];
}
}
}
int idx01 = ip * ido;
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido;
int idx5 = idx4 + idx1;
int idx6 = idx4 + idx2;
int idx7 = k * idx01;
in[in_off + ido - 1 + idx3 - ido + idx7] = out[out_off + idx5];
in[in_off + idx3 + idx7] = out[out_off + idx6];
}
}
if (ido == 1)
return;
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * idx01;
int idx5 = k * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx6 = in_off + i;
int idx7 = in_off + ic;
int idx8 = out_off + i;
int iidx1 = idx6 + idx3 + idx4;
int iidx2 = idx7 + idx3 - ido + idx4;
int oidx1 = idx8 + idx5 + idx1;
int oidx2 = idx8 + idx5 + idx2;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx2 - 1] = o1i - o2i;
in[iidx1] = o1r + o2r;
in[iidx2] = o2r - o1r;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx6 = in_off + i;
int idx7 = in_off + ic;
int idx8 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx4 = k * idx01;
int idx5 = k * ido;
int iidx1 = idx6 + idx3 + idx4;
int iidx2 = idx7 + idx3 - ido + idx4;
int oidx1 = idx8 + idx5 + idx1;
int oidx2 = idx8 + idx5 + idx2;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx2 - 1] = o1i - o2i;
in[iidx1] = o1r + o2r;
in[iidx2] = o2r - o1r;
}
}
}
}
}
/*---------------------------------------------------------
radbg: Real FFT's backward processing of general factor
-------------------------------------------------------- | FloatFFT::radbg | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
void cfftf(float[] a, int offa, int isign) {
int idot;
int l1, l2;
int na, nf, ip, iw, ido, idl1;
int[] nac = new int[1];
final int twon = 2 * n;
int iw1, iw2;
float[] ch = new float[twon];
iw1 = twon;
iw2 = 4 * n;
nac[0] = 0;
nf = (int) wtable[1 + iw2];
na = 0;
l1 = 1;
iw = iw1;
for (int k1 = 2; k1 <= nf + 1; k1++) {
ip = (int) wtable[k1 + iw2];
l2 = ip * l1;
ido = n / l2;
idot = ido + ido;
idl1 = idot * l1;
switch (ip) {
case 4:
if (na == 0) {
passf4(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf4(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
case 2:
if (na == 0) {
passf2(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf2(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
passf3(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf3(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
passf5(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf5(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
default:
if (na == 0) {
passfg(nac, idot, ip, l1, idl1, a, offa, ch, 0, iw, isign);
} else {
passfg(nac, idot, ip, l1, idl1, ch, 0, a, offa, iw, isign);
}
if (nac[0] != 0)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * idot;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, twon);
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. This method computes the full real inverse transform, i.e. you will get
the same result as from <code>complexInverse</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
public void realInverseFull(final float[] a, final int offa, boolean scale) {
final int twon = 2 * n;
switch (plan) {
case SPLIT_RADIX:
realInverse2(a, offa, scale);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n / 2 > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
Future<?>[] futures = new Future[nthreads];
int k = n / 2 / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n / 2 : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
int idx1, idx2;
for (int k = firstIdx; k < lastIdx; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
int idx1, idx2;
for (int k = 0; k < n / 2; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
a[offa + n] = -a[offa + 1];
a[offa + 1] = 0;
break;
case MIXED_RADIX:
rfftf(a, offa);
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
} else {
m = (n + 1) / 2;
}
for (int k = 1; k < m; k++) {
int idx1 = offa + 2 * k;
int idx2 = offa + twon - 2 * k;
a[idx1] = -a[idx1];
a[idx2 + 1] = -a[idx1];
a[idx2] = a[idx1 - 1];
}
for (int k = 1; k < n; k++) {
int idx = offa + n - k;
float tmp = a[idx + 1];
a[idx + 1] = a[idx];
a[idx] = tmp;
}
a[offa + 1] = 0;
break;
case BLUESTEIN:
bluestein_real_full(a, offa, 1);
if (scale) {
scale(n, a, offa, true);
}
break;
}
}
private void realInverse2(float[] a, int offa, boolean scale) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
float xi;
if (n > 4) {
cftfsub(n, a, offa, ip, nw, w);
rftbsub(n, a, offa, nc, w, nw);
} else if (n == 4) {
cftbsub(n, a, offa, ip, nw, w);
}
xi = a[offa] - a[offa + 1];
a[offa] += a[offa + 1];
a[offa + 1] = xi;
if (scale) {
scale(n, a, offa, false);
}
break;
case MIXED_RADIX:
rfftf(a, offa);
for (int k = n - 1; k >= 2; k--) {
int idx = offa + k;
float tmp = a[idx];
a[idx] = a[idx - 1];
a[idx - 1] = tmp;
}
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
for (int i = 1; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
} else {
m = (n - 1) / 2;
for (int i = 0; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
}
break;
case BLUESTEIN:
bluestein_real_inverse2(a, offa);
if (scale) {
scale(n, a, offa, false);
}
break;
}
}
private static int getReminder(int n, int[] factors) {
int reminder = n;
if (n <= 0) {
throw new IllegalArgumentException("n must be positive integer");
}
for (int i = 0; i < factors.length && reminder != 1; i++) {
int factor = factors[i];
while ((reminder % factor) == 0) {
reminder /= factor;
}
}
return reminder;
}
/* -------- initializing routines --------
/*---------------------------------------------------------
cffti: initialization of Complex FFT
--------------------------------------------------------
void cffti(int n, int offw) {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[offw + nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[offw + idx + 1] = wtable[offw + idx];
}
wtable[offw + 2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[offw + fourn] = n;
wtable[offw + 1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[offw + k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[offw + i - 1 + twon] = 1;
wtable[offw + i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[offw + idx - 1] = (float)Math.cos(arg);
wtable[offw + idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[offw + idx1 - 1] = wtable[offw + idx2 - 1];
wtable[offw + idx1] = wtable[offw + idx2];
}
}
l1 = l2;
}
}
void cffti() {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[idx + 1] = wtable[idx];
}
wtable[2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[fourn] = n;
wtable[1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[i - 1 + twon] = 1;
wtable[i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[idx - 1] = (float)Math.cos(arg);
wtable[idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[idx1 - 1] = wtable[idx2 - 1];
wtable[idx1] = wtable[idx2];
}
}
l1 = l2;
}
}
void rffti() {
if (n == 1)
return;
final int twon = 2 * n;
float argh;
int ntry = 0, i, j;
float argld;
int k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, is, nq, nr;
float arg;
int ido, ipm;
int nfm1;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
++j;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
++nf;
wtable_r[nf + 1 + twon] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + twon;
wtable_r[idx + 1] = wtable_r[idx];
}
wtable_r[2 + twon] = 2;
}
} while (nl != 1);
break;
}
wtable_r[twon] = n;
wtable_r[1 + twon] = nf;
argh = TWO_PI / (float) (n);
is = 0;
nfm1 = nf - 1;
l1 = 1;
if (nfm1 == 0)
return;
for (k1 = 1; k1 <= nfm1; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
ipm = ip - 1;
for (j = 1; j <= ipm; ++j) {
ld += l1;
i = is;
argld = (float) ld * argh;
fi = 0;
for (ii = 3; ii <= ido; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + n;
wtable_r[idx - 2] = (float)Math.cos(arg);
wtable_r[idx - 1] = (float)Math.sin(arg);
}
is += ido;
}
l1 = l2;
}
}
private void bluesteini() {
int k = 0;
float arg;
float pi_n = PI / n;
bk1[0] = 1;
bk1[1] = 0;
for (int i = 1; i < n; i++) {
k += 2 * i - 1;
if (k >= 2 * n)
k -= 2 * n;
arg = pi_n * k;
bk1[2 * i] = (float)Math.cos(arg);
bk1[2 * i + 1] = (float)Math.sin(arg);
}
float scale = (float)(1.0 / nBluestein);
bk2[0] = bk1[0] * scale;
bk2[1] = bk1[1] * scale;
for (int i = 2; i < 2 * n; i += 2) {
bk2[i] = bk1[i] * scale;
bk2[i + 1] = bk1[i + 1] * scale;
bk2[2 * nBluestein - i] = bk2[i];
bk2[2 * nBluestein - i + 1] = bk2[i + 1];
}
cftbsub(2 * nBluestein, bk2, 0, ip, nw, w);
}
private void makewt(int nw) {
int j, nwh, nw0, nw1;
float delta, wn4r, wk1r, wk1i, wk3r, wk3i;
float delta2, deltaj, deltaj3;
ip[0] = nw;
ip[1] = 1;
if (nw > 2) {
nwh = nw >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nwh);
delta2 = delta * 2;
wn4r = (float)Math.cos(delta * nwh);
w[0] = 1;
w[1] = wn4r;
if (nwh == 4) {
w[2] = (float)Math.cos(delta2);
w[3] = (float)Math.sin(delta2);
} else if (nwh > 4) {
makeipt(nw);
w[2] = (float)(0.5 / Math.cos(delta2));
w[3] = (float)(0.5 / Math.cos(delta * 6));
for (j = 4; j < nwh; j += 4) {
deltaj = delta * j;
deltaj3 = 3 * deltaj;
w[j] = (float)Math.cos(deltaj);
w[j + 1] = (float)Math.sin(deltaj);
w[j + 2] = (float)Math.cos(deltaj3);
w[j + 3] = (float)-Math.sin(deltaj3);
}
}
nw0 = 0;
while (nwh > 2) {
nw1 = nw0 + nwh;
nwh >>= 1;
w[nw1] = 1;
w[nw1 + 1] = wn4r;
if (nwh == 4) {
wk1r = w[nw0 + 4];
wk1i = w[nw0 + 5];
w[nw1 + 2] = wk1r;
w[nw1 + 3] = wk1i;
} else if (nwh > 4) {
wk1r = w[nw0 + 4];
wk3r = w[nw0 + 6];
w[nw1 + 2] = (float)(0.5 / wk1r);
w[nw1 + 3] = (float)(0.5 / wk3r);
for (j = 4; j < nwh; j += 4) {
int idx1 = nw0 + 2 * j;
int idx2 = nw1 + j;
wk1r = w[idx1];
wk1i = w[idx1 + 1];
wk3r = w[idx1 + 2];
wk3i = w[idx1 + 3];
w[idx2] = wk1r;
w[idx2 + 1] = wk1i;
w[idx2 + 2] = wk3r;
w[idx2 + 3] = wk3i;
}
}
nw0 = nw1;
}
}
}
private void makeipt(int nw) {
int j, l, m, m2, p, q;
ip[2] = 0;
ip[3] = 16;
m = 2;
for (l = nw; l > 32; l >>= 2) {
m2 = m << 1;
q = m2 << 3;
for (j = m; j < m2; j++) {
p = ip[j] << 2;
ip[m + j] = p;
ip[m2 + j] = p + q;
}
m = m2;
}
}
private void makect(int nc, float[] c, int startc) {
int j, nch;
float delta, deltaj;
ip[1] = nc;
if (nc > 1) {
nch = nc >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nch);
c[startc] = (float)Math.cos(delta * nch);
c[startc + nch] = (float)(0.5 * c[startc]);
for (j = 1; j < nch; j++) {
deltaj = delta * j;
c[startc + j] = (float)(0.5 * Math.cos(deltaj));
c[startc + nc - j] = (float)(0.5 * Math.sin(deltaj));
}
}
}
private void bluestein_complex(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_full(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_forward(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] + bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = -bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] + bk1[n] * ak[n];
}
}
private void bluestein_real_inverse(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
if (n % 2 == 0) {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n] = a[offa + 1] * bk1[n];
ak[n + 1] = a[offa + 1] * bk1[n + 1];
for (int i = n / 2 + 1; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
} else {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n - 1] = a[offa + n - 1] * bk1[n - 1] - a[offa + 1] * bk1[n];
ak[n] = a[offa + n - 1] * bk1[n] + a[offa + 1] * bk1[n - 1];
ak[n + 1] = a[offa + n - 1] * bk1[n + 1] + a[offa + 1] * bk1[n + 2];
ak[n + 2] = a[offa + n - 1] * bk1[n + 2] - a[offa + 1] * bk1[n + 1];
for (int i = (n - 1) / 2 + 2; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
}
private void bluestein_real_inverse2(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] - bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] - bk1[n] * ak[n];
}
}
/*---------------------------------------------------------
rfftf1: further processing of Real forward FFT
--------------------------------------------------------
void rfftf(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, kh, nf, ip, iw, ido, idl1;
final float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 1;
l2 = n;
iw = twon - 1;
for (int k1 = 1; k1 <= nf; ++k1) {
kh = nf - k1;
ip = (int) wtable_r[kh + 2 + twon];
l1 = l2 / ip;
ido = n / l2;
idl1 = ido * l1;
iw -= (ip - 1) * ido;
na = 1 - na;
switch (ip) {
case 2:
if (na == 0) {
radf2(ido, l1, a, offa, ch, 0, iw);
} else {
radf2(ido, l1, ch, 0, a, offa, iw);
}
break;
case 3:
if (na == 0) {
radf3(ido, l1, a, offa, ch, 0, iw);
} else {
radf3(ido, l1, ch, 0, a, offa, iw);
}
break;
case 4:
if (na == 0) {
radf4(ido, l1, a, offa, ch, 0, iw);
} else {
radf4(ido, l1, ch, 0, a, offa, iw);
}
break;
case 5:
if (na == 0) {
radf5(ido, l1, a, offa, ch, 0, iw);
} else {
radf5(ido, l1, ch, 0, a, offa, iw);
}
break;
default:
if (ido == 1)
na = 1 - na;
if (na == 0) {
radfg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
na = 1;
} else {
radfg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
na = 0;
}
break;
}
l2 = l1;
}
if (na == 1)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*---------------------------------------------------------
rfftb1: further processing of Real backward FFT
--------------------------------------------------------
void rfftb(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, nf, ip, iw, ido, idl1;
float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 0;
l1 = 1;
iw = n;
for (int k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
l2 = ip * l1;
ido = n / l2;
idl1 = ido * l1;
switch (ip) {
case 2:
if (na == 0) {
radb2(ido, l1, a, offa, ch, 0, iw);
} else {
radb2(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
radb3(ido, l1, a, offa, ch, 0, iw);
} else {
radb3(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 4:
if (na == 0) {
radb4(ido, l1, a, offa, ch, 0, iw);
} else {
radb4(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
radb5(ido, l1, a, offa, ch, 0, iw);
} else {
radb5(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
default:
if (na == 0) {
radbg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
} else {
radbg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
}
if (ido == 1)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * ido;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*-------------------------------------------------
radf2: Real FFT's forward processing of factor 2
-------------------------------------------------
void radf2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic, idx0, idx1, idx2, idx3, idx4;
float t1i, t1r, w1r, w1i;
int iw1;
iw1 = offset;
idx0 = l1 * ido;
idx1 = 2 * ido;
for (int k = 0; k < l1; k++) {
int oidx1 = out_off + k * idx1;
int oidx2 = oidx1 + idx1 - 1;
int iidx1 = in_off + k * ido;
int iidx2 = iidx1 + idx0;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx2] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
idx2 = 2 * idx1;
idx3 = idx2 + ido;
idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int oidx1 = out_off + i + idx2;
int oidx2 = out_off + ic + idx3;
int iidx1 = in_off + i + idx1;
int iidx2 = in_off + i + idx4;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
t1r = w1r * a2i + w1i * a2r;
t1i = w1r * a2r - w1i * a2i;
out[oidx1] = a1r + t1i;
out[oidx1 - 1] = a1i + t1r;
out[oidx2] = t1i - a1r;
out[oidx2 - 1] = a1i - t1r;
}
}
if (ido % 2 == 1)
return;
}
idx2 = 2 * idx1;
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
int oidx1 = out_off + idx2 + ido;
int iidx1 = in_off + ido - 1 + idx1;
out[oidx1] = -in[iidx1 + idx0];
out[oidx1 - 1] = in[iidx1];
}
}
/*-------------------------------------------------
radb2: Real FFT's backward processing of factor 2
-------------------------------------------------
void radb2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic;
float t1i, t1r, w1r, w1i;
int iw1 = offset;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int oidx1 = out_off + idx1;
int iidx1 = in_off + idx2;
int iidx2 = in_off + ido - 1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx1 + idx0] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx5 = i - 1 + iw1;
int idx6 = out_off + i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
w1r = wtable_r[idx5 - 1];
w1i = wtable_r[idx5];
int iidx1 = idx7 + idx2;
int iidx2 = idx8 + idx3;
int oidx1 = idx6 + idx1;
int oidx2 = idx6 + idx4;
t1r = in[iidx1 - 1] - in[iidx2 - 1];
t1i = in[iidx1] + in[iidx2];
float i1i = in[iidx1];
float i1r = in[iidx1 - 1];
float i2i = in[iidx2];
float i2r = in[iidx2 - 1];
out[oidx1 - 1] = i1r + i2r;
out[oidx1] = i1i - i2i;
out[oidx2 - 1] = w1r * t1r - w1i * t1i;
out[oidx2] = w1r * t1i + w1i * t1r;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int oidx1 = out_off + ido - 1 + idx1;
int iidx1 = in_off + idx2 + ido;
out[oidx1] = 2 * in[iidx1 - 1];
out[oidx1 + idx0] = -2 * in[iidx1];
}
}
/*-------------------------------------------------
radf3: Real FFT's forward processing of factor 3
-------------------------------------------------
void radf3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, di2, di3, cr2, dr2, dr3, ti2, ti3, tr2, tr3, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx3 = 2 * idx0;
int idx4 = (3 * k + 1) * ido;
int iidx1 = in_off + idx1;
int iidx2 = iidx1 + idx0;
int iidx3 = iidx1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
float i3r = in[iidx3];
cr2 = i2r + i3r;
out[out_off + 3 * idx1] = i1r + cr2;
out[out_off + idx4 + ido] = taui * (i3r - i2r);
out[out_off + ido - 1 + idx4] = i1r + taur * cr2;
}
if (ido == 1)
return;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int idx4 = 3 * idx3;
int idx5 = idx3 + idx0;
int idx6 = idx5 + idx0;
int idx7 = idx4 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx3;
int iidx2 = idx9 + idx5;
int iidx3 = idx9 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
cr2 = dr2 + dr3;
ci2 = di2 + di3;
tr2 = i1i + taur * cr2;
ti2 = i1r + taur * ci2;
tr3 = taui * (di2 - di3);
ti3 = taui * (dr3 - dr2);
int oidx1 = idx10 + idx4;
int oidx2 = idx11 + idx7;
int oidx3 = idx10 + idx8;
out[oidx1 - 1] = i1i + cr2;
out[oidx1] = i1r + ci2;
out[oidx2 - 1] = tr2 - tr3;
out[oidx2] = ti3 - ti2;
out[oidx3 - 1] = tr2 + tr3;
out[oidx3] = ti2 + ti3;
}
}
}
/*-------------------------------------------------
radb3: Real FFT's backward processing of factor 3
-------------------------------------------------
void radb3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, ci3, di2, di3, cr2, cr3, dr2, dr3, ti2, tr2, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int iidx1 = in_off + 3 * idx1;
int iidx2 = iidx1 + 2 * ido;
float i1i = in[iidx1];
tr2 = 2 * in[iidx2 - 1];
cr2 = i1i + taur * tr2;
ci3 = 2 * taui * in[iidx2];
out[out_off + idx1] = i1i + tr2;
out[out_off + (k + l1) * ido] = cr2 - ci3;
out[out_off + (k + 2 * l1) * ido] = cr2 + ci3;
}
if (ido == 1)
return;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 3 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx1 + idx0;
int idx6 = idx5 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
int idx9 = out_off + i;
int iidx1 = idx7 + idx2;
int iidx2 = idx7 + idx4;
int iidx3 = idx8 + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
tr2 = i2i + i3i;
cr2 = i1i + taur * tr2;
ti2 = i2r - i3r;
ci2 = i1r + taur * ti2;
cr3 = taui * (i2i - i3i);
ci3 = taui * (i2r + i3r);
dr2 = cr2 - ci3;
dr3 = cr2 + ci3;
di2 = ci2 + cr3;
di3 = ci2 - cr3;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int oidx1 = idx9 + idx1;
int oidx2 = idx9 + idx5;
int oidx3 = idx9 + idx6;
out[oidx1 - 1] = i1i + tr2;
out[oidx1] = i1r + ti2;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
}
}
}
/*-------------------------------------------------
radf4: Real FFT's forward processing of factor 4
-------------------------------------------------
void radf4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float hsqt2 = 0.707106781186547572737310929369414225f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = offset + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx3];
float i3r = in[in_off + idx4];
float i4r = in[in_off + idx5];
tr1 = i2r + i4r;
tr2 = i1r + i3r;
int oidx1 = out_off + idx2;
int oidx2 = out_off + idx6 + ido;
out[oidx1] = tr1 + tr2;
out[oidx2 - 1 + ido + ido] = tr2 - tr1;
out[oidx2 - 1] = i1r - i3r;
out[oidx2] = i4r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx1;
int iidx2 = idx9 + idx2;
int iidx3 = idx9 + idx3;
int iidx4 = idx9 + idx4;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
cr2 = w1r * i2i + w1i * i2r;
ci2 = w1r * i2r - w1i * i2i;
cr3 = w2r * i3i + w2i * i3r;
ci3 = w2r * i3r - w2i * i3i;
cr4 = w3r * i4i + w3i * i4r;
ci4 = w3r * i4r - w3i * i4i;
tr1 = cr2 + cr4;
tr4 = cr4 - cr2;
ti1 = ci2 + ci4;
ti4 = ci2 - ci4;
ti2 = i1r + ci3;
ti3 = i1r - ci3;
tr2 = i1i + cr3;
tr3 = i1i - cr3;
int oidx1 = idx10 + idx5;
int oidx2 = idx11 + idx6;
int oidx3 = idx10 + idx7;
int oidx4 = idx11 + idx8;
out[oidx1 - 1] = tr1 + tr2;
out[oidx4 - 1] = tr2 - tr1;
out[oidx1] = ti1 + ti2;
out[oidx4] = ti1 - ti2;
out[oidx3 - 1] = ti4 + tr3;
out[oidx2 - 1] = tr3 - ti4;
out[oidx3] = tr4 + ti3;
out[oidx2] = tr4 - ti3;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1i = in[idx9 - 1 + idx1];
float i2i = in[idx9 - 1 + idx3];
float i3i = in[idx9 - 1 + idx4];
float i4i = in[idx9 - 1 + idx5];
ti1 = -hsqt2 * (i2i + i4i);
tr1 = hsqt2 * (i2i - i4i);
out[idx10 - 1 + idx2] = tr1 + i1i;
out[idx10 - 1 + idx7] = i1i - tr1;
out[out_off + idx6] = ti1 - i3i;
out[out_off + idx8] = ti1 + i3i;
}
}
/*-------------------------------------------------
radb4: Real FFT's backward processing of factor 4
-------------------------------------------------
void radb4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float sqrt2 = 1.41421356237309514547462185873882845f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4;
float ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
float i1r = in[in_off + idx2];
float i2r = in[in_off + idx7];
float i3r = in[in_off + ido - 1 + idx8];
float i4r = in[in_off + ido - 1 + idx6];
tr1 = i1r - i3r;
tr2 = i1r + i3r;
tr3 = i4r + i4r;
tr4 = i2r + i2r;
out[out_off + idx1] = tr2 + tr3;
out[out_off + idx3] = tr1 - tr4;
out[out_off + idx4] = tr2 - tr3;
out[out_off + idx5] = tr1 + tr4;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx12 = in_off + i;
int idx13 = in_off + ic;
int idx14 = out_off + i;
int iidx1 = idx12 + idx5;
int iidx2 = idx13 + idx6;
int iidx3 = idx12 + idx7;
int iidx4 = idx13 + idx8;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
ti1 = i1r + i4r;
ti2 = i1r - i4r;
ti3 = i3r - i2r;
tr4 = i3r + i2r;
tr1 = i1i - i4i;
tr2 = i1i + i4i;
ti4 = i3i - i2i;
tr3 = i3i + i2i;
cr3 = tr2 - tr3;
ci3 = ti2 - ti3;
cr2 = tr1 - tr4;
cr4 = tr1 + tr4;
ci2 = ti1 + ti4;
ci4 = ti1 - ti4;
int oidx1 = idx14 + idx1;
int oidx2 = idx14 + idx2;
int oidx3 = idx14 + idx3;
int oidx4 = idx14 + idx4;
out[oidx1 - 1] = tr2 + tr3;
out[oidx1] = ti2 + ti3;
out[oidx2 - 1] = w1r * cr2 - w1i * ci2;
out[oidx2] = w1r * ci2 + w1i * cr2;
out[oidx3 - 1] = w2r * cr3 - w2i * ci3;
out[oidx3] = w2r * ci3 + w2i * cr3;
out[oidx4 - 1] = w3r * cr4 - w3i * ci4;
out[oidx4] = w3r * ci4 + w3i * cr4;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1r = in[idx9 - 1 + idx2];
float i2r = in[idx9 - 1 + idx7];
float i3r = in[in_off + idx6];
float i4r = in[in_off + idx8];
ti1 = i3r + i4r;
ti2 = i4r - i3r;
tr1 = i1r - i2r;
tr2 = i1r + i2r;
out[idx10 - 1 + idx1] = tr2 + tr2;
out[idx10 - 1 + idx3] = sqrt2 * (tr1 - ti1);
out[idx10 - 1 + idx4] = ti2 + ti2;
out[idx10 - 1 + idx5] = -sqrt2 * (tr1 + ti1);
}
}
/*-------------------------------------------------
radf5: Real FFT's forward processing of factor 5
-------------------------------------------------
void radf5(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float tr11 = 0.309016994374947451262869435595348477f;
final float ti11 = 0.951056516295153531181938433292089030f;
final float tr12 = -0.809016994374947340240566973079694435f;
final float ti12 = 0.587785252292473248125759255344746634f;
int i, ic;
float ci2, di2, ci4, ci5, di3, di4, di5, ci3, cr2, cr3, dr2, dr3, dr4, dr5, cr5, cr4, ti2, ti3, ti5, ti4, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
int iw1, iw2, iw3, iw4;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
iw4 = iw3 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
int idx11 = out_off + ido - 1;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx7];
float i3r = in[in_off + idx8];
float i4r = in[in_off + idx9];
float i5r = in[in_off + idx10];
cr2 = i5r + i2r;
ci5 = i5r - i2r;
cr3 = i4r + i3r;
ci4 = i4r - i3r;
out[out_off + idx2] = i1r + cr2 + cr3;
out[idx11 + idx3] = i1r + tr11 * cr2 + tr12 * cr3;
out[out_off + idx4] = ti11 * ci5 + ti12 * ci4;
out[idx11 + idx5] = i1r + tr12 * cr2 + tr11 * cr3;
out[out_off + idx6] = ti12 * ci5 - ti11 * ci4;
}
if (ido == 1)
return;
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
for (i = 2; i < ido; i += 2) {
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
int widx4 = i - 1 + iw4;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
w4r = wtable_r[widx4 - 1];
w4i = wtable_r[widx4];
ic = ido - i;
int idx15 = in_off + i;
int idx16 = out_off + i;
int idx17 = out_off + ic;
int iidx1 = idx15 + idx1;
int iidx2 = idx15 + idx7;
int iidx3 = idx15 + idx8;
int iidx4 = idx15 + idx9;
int iidx5 = idx15 + idx10;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
dr4 = w3r * i4i + w3i * i4r;
di4 = w3r * i4r - w3i * i4i;
dr5 = w4r * i5i + w4i * i5r;
di5 = w4r * i5r - w4i * i5i;
cr2 = dr2 + dr5;
ci5 = dr5 - dr2;
cr5 = di2 - di5;
ci2 = di2 + di5;
cr3 = dr3 + dr4;
ci4 = dr4 - dr3;
cr4 = di3 - di4;
ci3 = di3 + di4;
tr2 = i1i + tr11 * cr2 + tr12 * cr3;
ti2 = i1r + tr11 * ci2 + tr12 * ci3;
tr3 = i1i + tr12 * cr2 + tr11 * cr3;
ti3 = i1r + tr12 * ci2 + tr11 * ci3;
tr5 = ti11 * cr5 + ti12 * cr4;
ti5 = ti11 * ci5 + ti12 * ci4;
tr4 = ti12 * cr5 - ti11 * cr4;
ti4 = ti12 * ci5 - ti11 * ci4;
int oidx1 = idx16 + idx2;
int oidx2 = idx17 + idx3;
int oidx3 = idx16 + idx4;
int oidx4 = idx17 + idx5;
int oidx5 = idx16 + idx6;
out[oidx1 - 1] = i1i + cr2 + cr3;
out[oidx1] = i1r + ci2 + ci3;
out[oidx3 - 1] = tr2 + tr5;
out[oidx2 - 1] = tr2 - tr5;
out[oidx3] = ti2 + ti5;
out[oidx2] = ti5 - ti2;
out[oidx5 - 1] = tr3 + tr4;
out[oidx4 - 1] = tr3 - tr4;
out[oidx5] = ti3 + ti4;
out[oidx4] = ti4 - ti3;
}
}
}
/*-------------------------------------------------
radb5: Real FFT's backward processing of factor 5
-------------------------------------------------
void radb5(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float tr11 = 0.309016994374947451262869435595348477f;
final float ti11 = 0.951056516295153531181938433292089030f;
final float tr12 = -0.809016994374947340240566973079694435f;
final float ti12 = 0.587785252292473248125759255344746634f;
int i, ic;
float ci2, ci3, ci4, ci5, di3, di4, di5, di2, cr2, cr3, cr5, cr4, ti2, ti3, ti4, ti5, dr3, dr4, dr5, dr2, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
int iw1, iw2, iw3, iw4;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
iw4 = iw3 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
int idx11 = in_off + ido - 1;
float i1r = in[in_off + idx2];
ti5 = 2 * in[in_off + idx4];
ti4 = 2 * in[in_off + idx6];
tr2 = 2 * in[idx11 + idx3];
tr3 = 2 * in[idx11 + idx5];
cr2 = i1r + tr11 * tr2 + tr12 * tr3;
cr3 = i1r + tr12 * tr2 + tr11 * tr3;
ci5 = ti11 * ti5 + ti12 * ti4;
ci4 = ti12 * ti5 - ti11 * ti4;
out[out_off + idx1] = i1r + tr2 + tr3;
out[out_off + idx7] = cr2 - ci5;
out[out_off + idx8] = cr3 - ci4;
out[out_off + idx9] = cr3 + ci4;
out[out_off + idx10] = cr2 + ci5;
}
if (ido == 1)
return;
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
int widx4 = i - 1 + iw4;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
w4r = wtable_r[widx4 - 1];
w4i = wtable_r[widx4];
int idx15 = in_off + i;
int idx16 = in_off + ic;
int idx17 = out_off + i;
int iidx1 = idx15 + idx2;
int iidx2 = idx16 + idx3;
int iidx3 = idx15 + idx4;
int iidx4 = idx16 + idx5;
int iidx5 = idx15 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
ti5 = i3r + i2r;
ti2 = i3r - i2r;
ti4 = i5r + i4r;
ti3 = i5r - i4r;
tr5 = i3i - i2i;
tr2 = i3i + i2i;
tr4 = i5i - i4i;
tr3 = i5i + i4i;
cr2 = i1i + tr11 * tr2 + tr12 * tr3;
ci2 = i1r + tr11 * ti2 + tr12 * ti3;
cr3 = i1i + tr12 * tr2 + tr11 * tr3;
ci3 = i1r + tr12 * ti2 + tr11 * ti3;
cr5 = ti11 * tr5 + ti12 * tr4;
ci5 = ti11 * ti5 + ti12 * ti4;
cr4 = ti12 * tr5 - ti11 * tr4;
ci4 = ti12 * ti5 - ti11 * ti4;
dr3 = cr3 - ci4;
dr4 = cr3 + ci4;
di3 = ci3 + cr4;
di4 = ci3 - cr4;
dr5 = cr2 + ci5;
dr2 = cr2 - ci5;
di5 = ci2 - cr5;
di2 = ci2 + cr5;
int oidx1 = idx17 + idx1;
int oidx2 = idx17 + idx7;
int oidx3 = idx17 + idx8;
int oidx4 = idx17 + idx9;
int oidx5 = idx17 + idx10;
out[oidx1 - 1] = i1i + tr2 + tr3;
out[oidx1] = i1r + ti2 + ti3;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
out[oidx4 - 1] = w3r * dr4 - w3i * di4;
out[oidx4] = w3r * di4 + w3i * dr4;
out[oidx5 - 1] = w4r * dr5 - w4i * di5;
out[oidx5] = w4r * di5 + w4i * dr5;
}
}
}
/*---------------------------------------------------------
radfg: Real FFT's forward processing of general factor
--------------------------------------------------------
void radfg(final int ido, final int ip, final int l1, final int idl1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int idij, ipph, j2, ic, jc, lc, is, nbd;
float dc2, ai1, ai2, ar1, ar2, ds2, dcp, arg, dsp, ar1h, ar2h, w1r, w1i;
int iw1 = offset;
arg = TWO_PI / (float) ip;
dcp = (float)Math.cos(arg);
dsp = (float)Math.sin(arg);
ipph = (ip + 1) / 2;
nbd = (ido - 1) / 2;
if (ido != 1) {
if (idl1 >= 0) System.arraycopy(in, in_off, out, out_off, idl1);
for (int j = 1; j < ip; j++) {
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx2 = k * ido + idx1;
out[out_off + idx2] = in[in_off + idx2];
}
}
if (nbd <= l1) {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
idij = is - 1;
int idx1 = j * l1 * ido;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
int idx4 = in_off + i;
int idx5 = out_off + i;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int oidx1 = idx5 + idx3;
int iidx1 = idx4 + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
out[oidx1 - 1] = w1r * i1i + w1i * i1r;
out[oidx1] = w1r * i1r - w1i * i1i;
}
}
}
} else {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
idij = is - 1;
int idx3 = k * ido + idx1;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
int oidx1 = out_off + i + idx3;
int iidx1 = in_off + i + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
out[oidx1 - 1] = w1r * i1i + w1i * i1r;
out[oidx1] = w1r * i1r - w1i * i1i;
}
}
}
}
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
for (int i = 2; i < ido; i += 2) {
int idx5 = in_off + i;
int idx6 = out_off + i;
int iidx1 = idx5 + idx3;
int iidx2 = idx5 + idx4;
int oidx1 = idx6 + idx3;
int oidx2 = idx6 + idx4;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx1] = o1r + o2r;
in[iidx2 - 1] = o1r - o2r;
in[iidx2] = o2i - o1i;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int i = 2; i < ido; i += 2) {
int idx5 = in_off + i;
int idx6 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
int iidx1 = idx5 + idx3;
int iidx2 = idx5 + idx4;
int oidx1 = idx6 + idx3;
int oidx2 = idx6 + idx4;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx1] = o1r + o2r;
in[iidx2 - 1] = o1r - o2r;
in[iidx2] = o2i - o1i;
}
}
}
}
} else {
System.arraycopy(out, out_off, in, in_off, idl1);
}
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
int oidx1 = out_off + idx3;
int oidx2 = out_off + idx4;
float o1r = out[oidx1];
float o2r = out[oidx2];
in[in_off + idx3] = o1r + o2r;
in[in_off + idx4] = o2r - o1r;
}
}
ar1 = 1;
ai1 = 0;
int idx0 = (ip - 1) * idl1;
for (int l = 1; l < ipph; l++) {
lc = ip - l;
ar1h = dcp * ar1 - dsp * ai1;
ai1 = dcp * ai1 + dsp * ar1;
ar1 = ar1h;
int idx1 = l * idl1;
int idx2 = lc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx3 = out_off + ik;
int idx4 = in_off + ik;
out[idx3 + idx1] = in[idx4] + ar1 * in[idx4 + idl1];
out[idx3 + idx2] = ai1 * in[idx4 + idx0];
}
dc2 = ar1;
ds2 = ai1;
ar2 = ar1;
ai2 = ai1;
for (int j = 2; j < ipph; j++) {
jc = ip - j;
ar2h = dc2 * ar2 - ds2 * ai2;
ai2 = dc2 * ai2 + ds2 * ar2;
ar2 = ar2h;
int idx3 = j * idl1;
int idx4 = jc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx5 = out_off + ik;
int idx6 = in_off + ik;
out[idx5 + idx1] += ar2 * in[idx6 + idx3];
out[idx5 + idx2] += ai2 * in[idx6 + idx4];
}
}
}
for (int j = 1; j < ipph; j++) {
int idx1 = j * idl1;
for (int ik = 0; ik < idl1; ik++) {
out[out_off + ik] += in[in_off + ik + idx1];
}
}
if (ido >= l1) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = idx1 * ip;
for (int i = 0; i < ido; i++) {
in[in_off + i + idx2] = out[out_off + i + idx1];
}
}
} else {
for (int i = 0; i < ido; i++) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
in[in_off + i + idx1 * ip] = out[out_off + i + idx1];
}
}
}
int idx01 = ip * ido;
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido;
int idx5 = idx4 + idx1;
int idx6 = idx4 + idx2;
int idx7 = k * idx01;
in[in_off + ido - 1 + idx3 - ido + idx7] = out[out_off + idx5];
in[in_off + idx3 + idx7] = out[out_off + idx6];
}
}
if (ido == 1)
return;
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * idx01;
int idx5 = k * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx6 = in_off + i;
int idx7 = in_off + ic;
int idx8 = out_off + i;
int iidx1 = idx6 + idx3 + idx4;
int iidx2 = idx7 + idx3 - ido + idx4;
int oidx1 = idx8 + idx5 + idx1;
int oidx2 = idx8 + idx5 + idx2;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx2 - 1] = o1i - o2i;
in[iidx1] = o1r + o2r;
in[iidx2] = o2r - o1r;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx6 = in_off + i;
int idx7 = in_off + ic;
int idx8 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx4 = k * idx01;
int idx5 = k * ido;
int iidx1 = idx6 + idx3 + idx4;
int iidx2 = idx7 + idx3 - ido + idx4;
int oidx1 = idx8 + idx5 + idx1;
int oidx2 = idx8 + idx5 + idx2;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx2 - 1] = o1i - o2i;
in[iidx1] = o1r + o2r;
in[iidx2] = o2r - o1r;
}
}
}
}
}
/*---------------------------------------------------------
radbg: Real FFT's backward processing of general factor
--------------------------------------------------------
void radbg(final int ido, final int ip, final int l1, final int idl1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int idij, ipph, j2, ic, jc, lc, is;
float dc2, ai1, ai2, ar1, ar2, ds2, w1r, w1i;
int nbd;
float dcp, arg, dsp, ar1h, ar2h;
int iw1 = offset;
arg = TWO_PI / (float) ip;
dcp = (float)Math.cos(arg);
dsp = (float)Math.sin(arg);
nbd = (ido - 1) / 2;
ipph = (ip + 1) / 2;
int idx0 = ip * ido;
if (ido >= l1) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = k * idx0;
for (int i = 0; i < ido; i++) {
out[out_off + i + idx1] = in[in_off + i + idx2];
}
}
} else {
for (int i = 0; i < ido; i++) {
int idx1 = out_off + i;
int idx2 = in_off + i;
for (int k = 0; k < l1; k++) {
out[idx1 + k * ido] = in[idx2 + k * idx0];
}
}
}
int iidx0 = in_off + ido - 1;
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido;
int idx5 = idx4 * ip;
int iidx1 = iidx0 + idx3 + idx5 - ido;
int iidx2 = in_off + idx3 + idx5;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[out_off + idx4 + idx1] = i1r + i1r;
out[out_off + idx4 + idx2] = i2r + i2r;
}
}
if (ido != 1) {
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = 2 * j * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido + idx1;
int idx5 = k * ido + idx2;
int idx6 = k * ip * ido + idx3;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = out_off + i;
int idx8 = in_off + ic;
int idx9 = in_off + i;
int oidx1 = idx7 + idx4;
int oidx2 = idx7 + idx5;
int iidx1 = idx9 + idx6;
int iidx2 = idx8 + idx6 - ido;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
out[oidx1 - 1] = a1i + a2i;
out[oidx2 - 1] = a1i - a2i;
out[oidx1] = a1r - a2r;
out[oidx2] = a1r + a2r;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = 2 * j * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = out_off + i;
int idx8 = in_off + ic;
int idx9 = in_off + i;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido + idx1;
int idx5 = k * ido + idx2;
int idx6 = k * ip * ido + idx3;
int oidx1 = idx7 + idx4;
int oidx2 = idx7 + idx5;
int iidx1 = idx9 + idx6;
int iidx2 = idx8 + idx6 - ido;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
out[oidx1 - 1] = a1i + a2i;
out[oidx2 - 1] = a1i - a2i;
out[oidx1] = a1r - a2r;
out[oidx2] = a1r + a2r;
}
}
}
}
}
ar1 = 1;
ai1 = 0;
int idx01 = (ip - 1) * idl1;
for (int l = 1; l < ipph; l++) {
lc = ip - l;
ar1h = dcp * ar1 - dsp * ai1;
ai1 = dcp * ai1 + dsp * ar1;
ar1 = ar1h;
int idx1 = l * idl1;
int idx2 = lc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx3 = in_off + ik;
int idx4 = out_off + ik;
in[idx3 + idx1] = out[idx4] + ar1 * out[idx4 + idl1];
in[idx3 + idx2] = ai1 * out[idx4 + idx01];
}
dc2 = ar1;
ds2 = ai1;
ar2 = ar1;
ai2 = ai1;
for (int j = 2; j < ipph; j++) {
jc = ip - j;
ar2h = dc2 * ar2 - ds2 * ai2;
ai2 = dc2 * ai2 + ds2 * ar2;
ar2 = ar2h;
int idx5 = j * idl1;
int idx6 = jc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx7 = in_off + ik;
int idx8 = out_off + ik;
in[idx7 + idx1] += ar2 * out[idx8 + idx5];
in[idx7 + idx2] += ai2 * out[idx8 + idx6];
}
}
}
for (int j = 1; j < ipph; j++) {
int idx1 = j * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx2 = out_off + ik;
out[idx2] += out[idx2 + idx1];
}
}
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int oidx1 = out_off + idx3;
int iidx1 = in_off + idx3 + idx1;
int iidx2 = in_off + idx3 + idx2;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1 + idx1] = i1r - i2r;
out[oidx1 + idx2] = i1r + i2r;
}
}
if (ido == 1)
return;
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
for (int i = 2; i < ido; i += 2) {
int idx4 = out_off + i;
int idx5 = in_off + i;
int oidx1 = idx4 + idx3 + idx1;
int oidx2 = idx4 + idx3 + idx2;
int iidx1 = idx5 + idx3 + idx1;
int iidx2 = idx5 + idx3 + idx2;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
out[oidx1 - 1] = i1i - i2r;
out[oidx2 - 1] = i1i + i2r;
out[oidx1] = i1r + i2i;
out[oidx2] = i1r - i2i;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int i = 2; i < ido; i += 2) {
int idx4 = out_off + i;
int idx5 = in_off + i;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int oidx1 = idx4 + idx3 + idx1;
int oidx2 = idx4 + idx3 + idx2;
int iidx1 = idx5 + idx3 + idx1;
int iidx2 = idx5 + idx3 + idx2;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
out[oidx1 - 1] = i1i - i2r;
out[oidx2 - 1] = i1i + i2r;
out[oidx1] = i1r + i2i;
out[oidx2] = i1r - i2i;
}
}
}
}
System.arraycopy(out, out_off, in, in_off, idl1);
for (int j = 1; j < ip; j++) {
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx2 = k * ido + idx1;
in[in_off + idx2] = out[out_off + idx2];
}
}
if (nbd <= l1) {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
idij = is - 1;
int idx1 = j * l1 * ido;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
int idx4 = in_off + i;
int idx5 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int iidx1 = idx4 + idx3;
int oidx1 = idx5 + idx3;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
in[iidx1 - 1] = w1r * o1i - w1i * o1r;
in[iidx1] = w1r * o1r + w1i * o1i;
}
}
}
} else {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
idij = is - 1;
int idx3 = k * ido + idx1;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
int idx4 = in_off + i;
int idx5 = out_off + i;
int iidx1 = idx4 + idx3;
int oidx1 = idx5 + idx3;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
in[iidx1 - 1] = w1r * o1i - w1i * o1r;
in[iidx1] = w1r * o1r + w1i * o1i;
}
}
}
}
}
/*---------------------------------------------------------
cfftf1: further processing of Complex forward FFT
-------------------------------------------------------- | FloatFFT::cfftf | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
void passf3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset, final int isign) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
float ci2, ci3, di2, di3, cr2, cr3, dr2, dr3, ti2, tr2;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
final int idxt = l1 * ido;
if (ido == 2) {
for (int k = 1; k <= l1; k++) {
int iidx1 = in_off + (3 * k - 2) * ido;
int iidx2 = iidx1 + ido;
int iidx3 = iidx1 - ido;
float i1r = in[iidx1];
float i1i = in[iidx1 + 1];
float i2r = in[iidx2];
float i2i = in[iidx2 + 1];
float i3r = in[iidx3];
float i3i = in[iidx3 + 1];
tr2 = i1r + i2r;
cr2 = i3r + taur * tr2;
ti2 = i1i + i2i;
ci2 = i3i + taur * ti2;
cr3 = isign * taui * (i1r - i2r);
ci3 = isign * taui * (i1i - i2i);
int oidx1 = out_off + (k - 1) * ido;
int oidx2 = oidx1 + idxt;
int oidx3 = oidx2 + idxt;
out[oidx1] = in[iidx3] + tr2;
out[oidx1 + 1] = i3i + ti2;
out[oidx2] = cr2 - ci3;
out[oidx2 + 1] = ci2 + cr3;
out[oidx3] = cr2 + ci3;
out[oidx3 + 1] = ci2 - cr3;
}
} else {
for (int k = 1; k <= l1; k++) {
int idx1 = in_off + (3 * k - 2) * ido;
int idx2 = out_off + (k - 1) * ido;
for (int i = 0; i < ido - 1; i += 2) {
int iidx1 = i + idx1;
int iidx2 = iidx1 + ido;
int iidx3 = iidx1 - ido;
float a1r = in[iidx1];
float a1i = in[iidx1 + 1];
float a2r = in[iidx2];
float a2i = in[iidx2 + 1];
float a3r = in[iidx3];
float a3i = in[iidx3 + 1];
tr2 = a1r + a2r;
cr2 = a3r + taur * tr2;
ti2 = a1i + a2i;
ci2 = a3i + taur * ti2;
cr3 = isign * taui * (a1r - a2r);
ci3 = isign * taui * (a1i - a2i);
dr2 = cr2 - ci3;
dr3 = cr2 + ci3;
di2 = ci2 + cr3;
di3 = ci2 - cr3;
int widx1 = i + iw1;
int widx2 = i + iw2;
float w1r = wtable[widx1];
float w1i = isign * wtable[widx1 + 1];
float w2r = wtable[widx2];
float w2i = isign * wtable[widx2 + 1];
int oidx1 = i + idx2;
int oidx2 = oidx1 + idxt;
int oidx3 = oidx2 + idxt;
out[oidx1] = a3r + tr2;
out[oidx1 + 1] = a3i + ti2;
out[oidx2] = w1r * dr2 - w1i * di2;
out[oidx2 + 1] = w1r * di2 + w1i * dr2;
out[oidx3] = w2r * dr3 - w2i * di3;
out[oidx3 + 1] = w2r * di3 + w2i * dr3;
}
}
}
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. This method computes the full real inverse transform, i.e. you will get
the same result as from <code>complexInverse</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
public void realInverseFull(final float[] a, final int offa, boolean scale) {
final int twon = 2 * n;
switch (plan) {
case SPLIT_RADIX:
realInverse2(a, offa, scale);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n / 2 > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
Future<?>[] futures = new Future[nthreads];
int k = n / 2 / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n / 2 : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
int idx1, idx2;
for (int k = firstIdx; k < lastIdx; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
int idx1, idx2;
for (int k = 0; k < n / 2; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
a[offa + n] = -a[offa + 1];
a[offa + 1] = 0;
break;
case MIXED_RADIX:
rfftf(a, offa);
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
} else {
m = (n + 1) / 2;
}
for (int k = 1; k < m; k++) {
int idx1 = offa + 2 * k;
int idx2 = offa + twon - 2 * k;
a[idx1] = -a[idx1];
a[idx2 + 1] = -a[idx1];
a[idx2] = a[idx1 - 1];
}
for (int k = 1; k < n; k++) {
int idx = offa + n - k;
float tmp = a[idx + 1];
a[idx + 1] = a[idx];
a[idx] = tmp;
}
a[offa + 1] = 0;
break;
case BLUESTEIN:
bluestein_real_full(a, offa, 1);
if (scale) {
scale(n, a, offa, true);
}
break;
}
}
private void realInverse2(float[] a, int offa, boolean scale) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
float xi;
if (n > 4) {
cftfsub(n, a, offa, ip, nw, w);
rftbsub(n, a, offa, nc, w, nw);
} else if (n == 4) {
cftbsub(n, a, offa, ip, nw, w);
}
xi = a[offa] - a[offa + 1];
a[offa] += a[offa + 1];
a[offa + 1] = xi;
if (scale) {
scale(n, a, offa, false);
}
break;
case MIXED_RADIX:
rfftf(a, offa);
for (int k = n - 1; k >= 2; k--) {
int idx = offa + k;
float tmp = a[idx];
a[idx] = a[idx - 1];
a[idx - 1] = tmp;
}
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
for (int i = 1; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
} else {
m = (n - 1) / 2;
for (int i = 0; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
}
break;
case BLUESTEIN:
bluestein_real_inverse2(a, offa);
if (scale) {
scale(n, a, offa, false);
}
break;
}
}
private static int getReminder(int n, int[] factors) {
int reminder = n;
if (n <= 0) {
throw new IllegalArgumentException("n must be positive integer");
}
for (int i = 0; i < factors.length && reminder != 1; i++) {
int factor = factors[i];
while ((reminder % factor) == 0) {
reminder /= factor;
}
}
return reminder;
}
/* -------- initializing routines --------
/*---------------------------------------------------------
cffti: initialization of Complex FFT
--------------------------------------------------------
void cffti(int n, int offw) {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[offw + nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[offw + idx + 1] = wtable[offw + idx];
}
wtable[offw + 2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[offw + fourn] = n;
wtable[offw + 1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[offw + k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[offw + i - 1 + twon] = 1;
wtable[offw + i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[offw + idx - 1] = (float)Math.cos(arg);
wtable[offw + idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[offw + idx1 - 1] = wtable[offw + idx2 - 1];
wtable[offw + idx1] = wtable[offw + idx2];
}
}
l1 = l2;
}
}
void cffti() {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[idx + 1] = wtable[idx];
}
wtable[2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[fourn] = n;
wtable[1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[i - 1 + twon] = 1;
wtable[i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[idx - 1] = (float)Math.cos(arg);
wtable[idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[idx1 - 1] = wtable[idx2 - 1];
wtable[idx1] = wtable[idx2];
}
}
l1 = l2;
}
}
void rffti() {
if (n == 1)
return;
final int twon = 2 * n;
float argh;
int ntry = 0, i, j;
float argld;
int k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, is, nq, nr;
float arg;
int ido, ipm;
int nfm1;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
++j;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
++nf;
wtable_r[nf + 1 + twon] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + twon;
wtable_r[idx + 1] = wtable_r[idx];
}
wtable_r[2 + twon] = 2;
}
} while (nl != 1);
break;
}
wtable_r[twon] = n;
wtable_r[1 + twon] = nf;
argh = TWO_PI / (float) (n);
is = 0;
nfm1 = nf - 1;
l1 = 1;
if (nfm1 == 0)
return;
for (k1 = 1; k1 <= nfm1; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
ipm = ip - 1;
for (j = 1; j <= ipm; ++j) {
ld += l1;
i = is;
argld = (float) ld * argh;
fi = 0;
for (ii = 3; ii <= ido; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + n;
wtable_r[idx - 2] = (float)Math.cos(arg);
wtable_r[idx - 1] = (float)Math.sin(arg);
}
is += ido;
}
l1 = l2;
}
}
private void bluesteini() {
int k = 0;
float arg;
float pi_n = PI / n;
bk1[0] = 1;
bk1[1] = 0;
for (int i = 1; i < n; i++) {
k += 2 * i - 1;
if (k >= 2 * n)
k -= 2 * n;
arg = pi_n * k;
bk1[2 * i] = (float)Math.cos(arg);
bk1[2 * i + 1] = (float)Math.sin(arg);
}
float scale = (float)(1.0 / nBluestein);
bk2[0] = bk1[0] * scale;
bk2[1] = bk1[1] * scale;
for (int i = 2; i < 2 * n; i += 2) {
bk2[i] = bk1[i] * scale;
bk2[i + 1] = bk1[i + 1] * scale;
bk2[2 * nBluestein - i] = bk2[i];
bk2[2 * nBluestein - i + 1] = bk2[i + 1];
}
cftbsub(2 * nBluestein, bk2, 0, ip, nw, w);
}
private void makewt(int nw) {
int j, nwh, nw0, nw1;
float delta, wn4r, wk1r, wk1i, wk3r, wk3i;
float delta2, deltaj, deltaj3;
ip[0] = nw;
ip[1] = 1;
if (nw > 2) {
nwh = nw >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nwh);
delta2 = delta * 2;
wn4r = (float)Math.cos(delta * nwh);
w[0] = 1;
w[1] = wn4r;
if (nwh == 4) {
w[2] = (float)Math.cos(delta2);
w[3] = (float)Math.sin(delta2);
} else if (nwh > 4) {
makeipt(nw);
w[2] = (float)(0.5 / Math.cos(delta2));
w[3] = (float)(0.5 / Math.cos(delta * 6));
for (j = 4; j < nwh; j += 4) {
deltaj = delta * j;
deltaj3 = 3 * deltaj;
w[j] = (float)Math.cos(deltaj);
w[j + 1] = (float)Math.sin(deltaj);
w[j + 2] = (float)Math.cos(deltaj3);
w[j + 3] = (float)-Math.sin(deltaj3);
}
}
nw0 = 0;
while (nwh > 2) {
nw1 = nw0 + nwh;
nwh >>= 1;
w[nw1] = 1;
w[nw1 + 1] = wn4r;
if (nwh == 4) {
wk1r = w[nw0 + 4];
wk1i = w[nw0 + 5];
w[nw1 + 2] = wk1r;
w[nw1 + 3] = wk1i;
} else if (nwh > 4) {
wk1r = w[nw0 + 4];
wk3r = w[nw0 + 6];
w[nw1 + 2] = (float)(0.5 / wk1r);
w[nw1 + 3] = (float)(0.5 / wk3r);
for (j = 4; j < nwh; j += 4) {
int idx1 = nw0 + 2 * j;
int idx2 = nw1 + j;
wk1r = w[idx1];
wk1i = w[idx1 + 1];
wk3r = w[idx1 + 2];
wk3i = w[idx1 + 3];
w[idx2] = wk1r;
w[idx2 + 1] = wk1i;
w[idx2 + 2] = wk3r;
w[idx2 + 3] = wk3i;
}
}
nw0 = nw1;
}
}
}
private void makeipt(int nw) {
int j, l, m, m2, p, q;
ip[2] = 0;
ip[3] = 16;
m = 2;
for (l = nw; l > 32; l >>= 2) {
m2 = m << 1;
q = m2 << 3;
for (j = m; j < m2; j++) {
p = ip[j] << 2;
ip[m + j] = p;
ip[m2 + j] = p + q;
}
m = m2;
}
}
private void makect(int nc, float[] c, int startc) {
int j, nch;
float delta, deltaj;
ip[1] = nc;
if (nc > 1) {
nch = nc >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nch);
c[startc] = (float)Math.cos(delta * nch);
c[startc + nch] = (float)(0.5 * c[startc]);
for (j = 1; j < nch; j++) {
deltaj = delta * j;
c[startc + j] = (float)(0.5 * Math.cos(deltaj));
c[startc + nc - j] = (float)(0.5 * Math.sin(deltaj));
}
}
}
private void bluestein_complex(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_full(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_forward(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] + bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = -bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] + bk1[n] * ak[n];
}
}
private void bluestein_real_inverse(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
if (n % 2 == 0) {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n] = a[offa + 1] * bk1[n];
ak[n + 1] = a[offa + 1] * bk1[n + 1];
for (int i = n / 2 + 1; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
} else {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n - 1] = a[offa + n - 1] * bk1[n - 1] - a[offa + 1] * bk1[n];
ak[n] = a[offa + n - 1] * bk1[n] + a[offa + 1] * bk1[n - 1];
ak[n + 1] = a[offa + n - 1] * bk1[n + 1] + a[offa + 1] * bk1[n + 2];
ak[n + 2] = a[offa + n - 1] * bk1[n + 2] - a[offa + 1] * bk1[n + 1];
for (int i = (n - 1) / 2 + 2; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
}
private void bluestein_real_inverse2(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] - bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] - bk1[n] * ak[n];
}
}
/*---------------------------------------------------------
rfftf1: further processing of Real forward FFT
--------------------------------------------------------
void rfftf(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, kh, nf, ip, iw, ido, idl1;
final float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 1;
l2 = n;
iw = twon - 1;
for (int k1 = 1; k1 <= nf; ++k1) {
kh = nf - k1;
ip = (int) wtable_r[kh + 2 + twon];
l1 = l2 / ip;
ido = n / l2;
idl1 = ido * l1;
iw -= (ip - 1) * ido;
na = 1 - na;
switch (ip) {
case 2:
if (na == 0) {
radf2(ido, l1, a, offa, ch, 0, iw);
} else {
radf2(ido, l1, ch, 0, a, offa, iw);
}
break;
case 3:
if (na == 0) {
radf3(ido, l1, a, offa, ch, 0, iw);
} else {
radf3(ido, l1, ch, 0, a, offa, iw);
}
break;
case 4:
if (na == 0) {
radf4(ido, l1, a, offa, ch, 0, iw);
} else {
radf4(ido, l1, ch, 0, a, offa, iw);
}
break;
case 5:
if (na == 0) {
radf5(ido, l1, a, offa, ch, 0, iw);
} else {
radf5(ido, l1, ch, 0, a, offa, iw);
}
break;
default:
if (ido == 1)
na = 1 - na;
if (na == 0) {
radfg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
na = 1;
} else {
radfg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
na = 0;
}
break;
}
l2 = l1;
}
if (na == 1)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*---------------------------------------------------------
rfftb1: further processing of Real backward FFT
--------------------------------------------------------
void rfftb(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, nf, ip, iw, ido, idl1;
float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 0;
l1 = 1;
iw = n;
for (int k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
l2 = ip * l1;
ido = n / l2;
idl1 = ido * l1;
switch (ip) {
case 2:
if (na == 0) {
radb2(ido, l1, a, offa, ch, 0, iw);
} else {
radb2(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
radb3(ido, l1, a, offa, ch, 0, iw);
} else {
radb3(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 4:
if (na == 0) {
radb4(ido, l1, a, offa, ch, 0, iw);
} else {
radb4(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
radb5(ido, l1, a, offa, ch, 0, iw);
} else {
radb5(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
default:
if (na == 0) {
radbg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
} else {
radbg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
}
if (ido == 1)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * ido;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*-------------------------------------------------
radf2: Real FFT's forward processing of factor 2
-------------------------------------------------
void radf2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic, idx0, idx1, idx2, idx3, idx4;
float t1i, t1r, w1r, w1i;
int iw1;
iw1 = offset;
idx0 = l1 * ido;
idx1 = 2 * ido;
for (int k = 0; k < l1; k++) {
int oidx1 = out_off + k * idx1;
int oidx2 = oidx1 + idx1 - 1;
int iidx1 = in_off + k * ido;
int iidx2 = iidx1 + idx0;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx2] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
idx2 = 2 * idx1;
idx3 = idx2 + ido;
idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int oidx1 = out_off + i + idx2;
int oidx2 = out_off + ic + idx3;
int iidx1 = in_off + i + idx1;
int iidx2 = in_off + i + idx4;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
t1r = w1r * a2i + w1i * a2r;
t1i = w1r * a2r - w1i * a2i;
out[oidx1] = a1r + t1i;
out[oidx1 - 1] = a1i + t1r;
out[oidx2] = t1i - a1r;
out[oidx2 - 1] = a1i - t1r;
}
}
if (ido % 2 == 1)
return;
}
idx2 = 2 * idx1;
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
int oidx1 = out_off + idx2 + ido;
int iidx1 = in_off + ido - 1 + idx1;
out[oidx1] = -in[iidx1 + idx0];
out[oidx1 - 1] = in[iidx1];
}
}
/*-------------------------------------------------
radb2: Real FFT's backward processing of factor 2
-------------------------------------------------
void radb2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic;
float t1i, t1r, w1r, w1i;
int iw1 = offset;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int oidx1 = out_off + idx1;
int iidx1 = in_off + idx2;
int iidx2 = in_off + ido - 1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx1 + idx0] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx5 = i - 1 + iw1;
int idx6 = out_off + i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
w1r = wtable_r[idx5 - 1];
w1i = wtable_r[idx5];
int iidx1 = idx7 + idx2;
int iidx2 = idx8 + idx3;
int oidx1 = idx6 + idx1;
int oidx2 = idx6 + idx4;
t1r = in[iidx1 - 1] - in[iidx2 - 1];
t1i = in[iidx1] + in[iidx2];
float i1i = in[iidx1];
float i1r = in[iidx1 - 1];
float i2i = in[iidx2];
float i2r = in[iidx2 - 1];
out[oidx1 - 1] = i1r + i2r;
out[oidx1] = i1i - i2i;
out[oidx2 - 1] = w1r * t1r - w1i * t1i;
out[oidx2] = w1r * t1i + w1i * t1r;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int oidx1 = out_off + ido - 1 + idx1;
int iidx1 = in_off + idx2 + ido;
out[oidx1] = 2 * in[iidx1 - 1];
out[oidx1 + idx0] = -2 * in[iidx1];
}
}
/*-------------------------------------------------
radf3: Real FFT's forward processing of factor 3
-------------------------------------------------
void radf3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, di2, di3, cr2, dr2, dr3, ti2, ti3, tr2, tr3, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx3 = 2 * idx0;
int idx4 = (3 * k + 1) * ido;
int iidx1 = in_off + idx1;
int iidx2 = iidx1 + idx0;
int iidx3 = iidx1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
float i3r = in[iidx3];
cr2 = i2r + i3r;
out[out_off + 3 * idx1] = i1r + cr2;
out[out_off + idx4 + ido] = taui * (i3r - i2r);
out[out_off + ido - 1 + idx4] = i1r + taur * cr2;
}
if (ido == 1)
return;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int idx4 = 3 * idx3;
int idx5 = idx3 + idx0;
int idx6 = idx5 + idx0;
int idx7 = idx4 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx3;
int iidx2 = idx9 + idx5;
int iidx3 = idx9 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
cr2 = dr2 + dr3;
ci2 = di2 + di3;
tr2 = i1i + taur * cr2;
ti2 = i1r + taur * ci2;
tr3 = taui * (di2 - di3);
ti3 = taui * (dr3 - dr2);
int oidx1 = idx10 + idx4;
int oidx2 = idx11 + idx7;
int oidx3 = idx10 + idx8;
out[oidx1 - 1] = i1i + cr2;
out[oidx1] = i1r + ci2;
out[oidx2 - 1] = tr2 - tr3;
out[oidx2] = ti3 - ti2;
out[oidx3 - 1] = tr2 + tr3;
out[oidx3] = ti2 + ti3;
}
}
}
/*-------------------------------------------------
radb3: Real FFT's backward processing of factor 3
-------------------------------------------------
void radb3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, ci3, di2, di3, cr2, cr3, dr2, dr3, ti2, tr2, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int iidx1 = in_off + 3 * idx1;
int iidx2 = iidx1 + 2 * ido;
float i1i = in[iidx1];
tr2 = 2 * in[iidx2 - 1];
cr2 = i1i + taur * tr2;
ci3 = 2 * taui * in[iidx2];
out[out_off + idx1] = i1i + tr2;
out[out_off + (k + l1) * ido] = cr2 - ci3;
out[out_off + (k + 2 * l1) * ido] = cr2 + ci3;
}
if (ido == 1)
return;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 3 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx1 + idx0;
int idx6 = idx5 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
int idx9 = out_off + i;
int iidx1 = idx7 + idx2;
int iidx2 = idx7 + idx4;
int iidx3 = idx8 + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
tr2 = i2i + i3i;
cr2 = i1i + taur * tr2;
ti2 = i2r - i3r;
ci2 = i1r + taur * ti2;
cr3 = taui * (i2i - i3i);
ci3 = taui * (i2r + i3r);
dr2 = cr2 - ci3;
dr3 = cr2 + ci3;
di2 = ci2 + cr3;
di3 = ci2 - cr3;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int oidx1 = idx9 + idx1;
int oidx2 = idx9 + idx5;
int oidx3 = idx9 + idx6;
out[oidx1 - 1] = i1i + tr2;
out[oidx1] = i1r + ti2;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
}
}
}
/*-------------------------------------------------
radf4: Real FFT's forward processing of factor 4
-------------------------------------------------
void radf4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float hsqt2 = 0.707106781186547572737310929369414225f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = offset + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx3];
float i3r = in[in_off + idx4];
float i4r = in[in_off + idx5];
tr1 = i2r + i4r;
tr2 = i1r + i3r;
int oidx1 = out_off + idx2;
int oidx2 = out_off + idx6 + ido;
out[oidx1] = tr1 + tr2;
out[oidx2 - 1 + ido + ido] = tr2 - tr1;
out[oidx2 - 1] = i1r - i3r;
out[oidx2] = i4r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx1;
int iidx2 = idx9 + idx2;
int iidx3 = idx9 + idx3;
int iidx4 = idx9 + idx4;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
cr2 = w1r * i2i + w1i * i2r;
ci2 = w1r * i2r - w1i * i2i;
cr3 = w2r * i3i + w2i * i3r;
ci3 = w2r * i3r - w2i * i3i;
cr4 = w3r * i4i + w3i * i4r;
ci4 = w3r * i4r - w3i * i4i;
tr1 = cr2 + cr4;
tr4 = cr4 - cr2;
ti1 = ci2 + ci4;
ti4 = ci2 - ci4;
ti2 = i1r + ci3;
ti3 = i1r - ci3;
tr2 = i1i + cr3;
tr3 = i1i - cr3;
int oidx1 = idx10 + idx5;
int oidx2 = idx11 + idx6;
int oidx3 = idx10 + idx7;
int oidx4 = idx11 + idx8;
out[oidx1 - 1] = tr1 + tr2;
out[oidx4 - 1] = tr2 - tr1;
out[oidx1] = ti1 + ti2;
out[oidx4] = ti1 - ti2;
out[oidx3 - 1] = ti4 + tr3;
out[oidx2 - 1] = tr3 - ti4;
out[oidx3] = tr4 + ti3;
out[oidx2] = tr4 - ti3;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1i = in[idx9 - 1 + idx1];
float i2i = in[idx9 - 1 + idx3];
float i3i = in[idx9 - 1 + idx4];
float i4i = in[idx9 - 1 + idx5];
ti1 = -hsqt2 * (i2i + i4i);
tr1 = hsqt2 * (i2i - i4i);
out[idx10 - 1 + idx2] = tr1 + i1i;
out[idx10 - 1 + idx7] = i1i - tr1;
out[out_off + idx6] = ti1 - i3i;
out[out_off + idx8] = ti1 + i3i;
}
}
/*-------------------------------------------------
radb4: Real FFT's backward processing of factor 4
-------------------------------------------------
void radb4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float sqrt2 = 1.41421356237309514547462185873882845f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4;
float ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
float i1r = in[in_off + idx2];
float i2r = in[in_off + idx7];
float i3r = in[in_off + ido - 1 + idx8];
float i4r = in[in_off + ido - 1 + idx6];
tr1 = i1r - i3r;
tr2 = i1r + i3r;
tr3 = i4r + i4r;
tr4 = i2r + i2r;
out[out_off + idx1] = tr2 + tr3;
out[out_off + idx3] = tr1 - tr4;
out[out_off + idx4] = tr2 - tr3;
out[out_off + idx5] = tr1 + tr4;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx12 = in_off + i;
int idx13 = in_off + ic;
int idx14 = out_off + i;
int iidx1 = idx12 + idx5;
int iidx2 = idx13 + idx6;
int iidx3 = idx12 + idx7;
int iidx4 = idx13 + idx8;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
ti1 = i1r + i4r;
ti2 = i1r - i4r;
ti3 = i3r - i2r;
tr4 = i3r + i2r;
tr1 = i1i - i4i;
tr2 = i1i + i4i;
ti4 = i3i - i2i;
tr3 = i3i + i2i;
cr3 = tr2 - tr3;
ci3 = ti2 - ti3;
cr2 = tr1 - tr4;
cr4 = tr1 + tr4;
ci2 = ti1 + ti4;
ci4 = ti1 - ti4;
int oidx1 = idx14 + idx1;
int oidx2 = idx14 + idx2;
int oidx3 = idx14 + idx3;
int oidx4 = idx14 + idx4;
out[oidx1 - 1] = tr2 + tr3;
out[oidx1] = ti2 + ti3;
out[oidx2 - 1] = w1r * cr2 - w1i * ci2;
out[oidx2] = w1r * ci2 + w1i * cr2;
out[oidx3 - 1] = w2r * cr3 - w2i * ci3;
out[oidx3] = w2r * ci3 + w2i * cr3;
out[oidx4 - 1] = w3r * cr4 - w3i * ci4;
out[oidx4] = w3r * ci4 + w3i * cr4;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1r = in[idx9 - 1 + idx2];
float i2r = in[idx9 - 1 + idx7];
float i3r = in[in_off + idx6];
float i4r = in[in_off + idx8];
ti1 = i3r + i4r;
ti2 = i4r - i3r;
tr1 = i1r - i2r;
tr2 = i1r + i2r;
out[idx10 - 1 + idx1] = tr2 + tr2;
out[idx10 - 1 + idx3] = sqrt2 * (tr1 - ti1);
out[idx10 - 1 + idx4] = ti2 + ti2;
out[idx10 - 1 + idx5] = -sqrt2 * (tr1 + ti1);
}
}
/*-------------------------------------------------
radf5: Real FFT's forward processing of factor 5
-------------------------------------------------
void radf5(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float tr11 = 0.309016994374947451262869435595348477f;
final float ti11 = 0.951056516295153531181938433292089030f;
final float tr12 = -0.809016994374947340240566973079694435f;
final float ti12 = 0.587785252292473248125759255344746634f;
int i, ic;
float ci2, di2, ci4, ci5, di3, di4, di5, ci3, cr2, cr3, dr2, dr3, dr4, dr5, cr5, cr4, ti2, ti3, ti5, ti4, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
int iw1, iw2, iw3, iw4;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
iw4 = iw3 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
int idx11 = out_off + ido - 1;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx7];
float i3r = in[in_off + idx8];
float i4r = in[in_off + idx9];
float i5r = in[in_off + idx10];
cr2 = i5r + i2r;
ci5 = i5r - i2r;
cr3 = i4r + i3r;
ci4 = i4r - i3r;
out[out_off + idx2] = i1r + cr2 + cr3;
out[idx11 + idx3] = i1r + tr11 * cr2 + tr12 * cr3;
out[out_off + idx4] = ti11 * ci5 + ti12 * ci4;
out[idx11 + idx5] = i1r + tr12 * cr2 + tr11 * cr3;
out[out_off + idx6] = ti12 * ci5 - ti11 * ci4;
}
if (ido == 1)
return;
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
for (i = 2; i < ido; i += 2) {
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
int widx4 = i - 1 + iw4;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
w4r = wtable_r[widx4 - 1];
w4i = wtable_r[widx4];
ic = ido - i;
int idx15 = in_off + i;
int idx16 = out_off + i;
int idx17 = out_off + ic;
int iidx1 = idx15 + idx1;
int iidx2 = idx15 + idx7;
int iidx3 = idx15 + idx8;
int iidx4 = idx15 + idx9;
int iidx5 = idx15 + idx10;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
dr4 = w3r * i4i + w3i * i4r;
di4 = w3r * i4r - w3i * i4i;
dr5 = w4r * i5i + w4i * i5r;
di5 = w4r * i5r - w4i * i5i;
cr2 = dr2 + dr5;
ci5 = dr5 - dr2;
cr5 = di2 - di5;
ci2 = di2 + di5;
cr3 = dr3 + dr4;
ci4 = dr4 - dr3;
cr4 = di3 - di4;
ci3 = di3 + di4;
tr2 = i1i + tr11 * cr2 + tr12 * cr3;
ti2 = i1r + tr11 * ci2 + tr12 * ci3;
tr3 = i1i + tr12 * cr2 + tr11 * cr3;
ti3 = i1r + tr12 * ci2 + tr11 * ci3;
tr5 = ti11 * cr5 + ti12 * cr4;
ti5 = ti11 * ci5 + ti12 * ci4;
tr4 = ti12 * cr5 - ti11 * cr4;
ti4 = ti12 * ci5 - ti11 * ci4;
int oidx1 = idx16 + idx2;
int oidx2 = idx17 + idx3;
int oidx3 = idx16 + idx4;
int oidx4 = idx17 + idx5;
int oidx5 = idx16 + idx6;
out[oidx1 - 1] = i1i + cr2 + cr3;
out[oidx1] = i1r + ci2 + ci3;
out[oidx3 - 1] = tr2 + tr5;
out[oidx2 - 1] = tr2 - tr5;
out[oidx3] = ti2 + ti5;
out[oidx2] = ti5 - ti2;
out[oidx5 - 1] = tr3 + tr4;
out[oidx4 - 1] = tr3 - tr4;
out[oidx5] = ti3 + ti4;
out[oidx4] = ti4 - ti3;
}
}
}
/*-------------------------------------------------
radb5: Real FFT's backward processing of factor 5
-------------------------------------------------
void radb5(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float tr11 = 0.309016994374947451262869435595348477f;
final float ti11 = 0.951056516295153531181938433292089030f;
final float tr12 = -0.809016994374947340240566973079694435f;
final float ti12 = 0.587785252292473248125759255344746634f;
int i, ic;
float ci2, ci3, ci4, ci5, di3, di4, di5, di2, cr2, cr3, cr5, cr4, ti2, ti3, ti4, ti5, dr3, dr4, dr5, dr2, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
int iw1, iw2, iw3, iw4;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
iw4 = iw3 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
int idx11 = in_off + ido - 1;
float i1r = in[in_off + idx2];
ti5 = 2 * in[in_off + idx4];
ti4 = 2 * in[in_off + idx6];
tr2 = 2 * in[idx11 + idx3];
tr3 = 2 * in[idx11 + idx5];
cr2 = i1r + tr11 * tr2 + tr12 * tr3;
cr3 = i1r + tr12 * tr2 + tr11 * tr3;
ci5 = ti11 * ti5 + ti12 * ti4;
ci4 = ti12 * ti5 - ti11 * ti4;
out[out_off + idx1] = i1r + tr2 + tr3;
out[out_off + idx7] = cr2 - ci5;
out[out_off + idx8] = cr3 - ci4;
out[out_off + idx9] = cr3 + ci4;
out[out_off + idx10] = cr2 + ci5;
}
if (ido == 1)
return;
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
int widx4 = i - 1 + iw4;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
w4r = wtable_r[widx4 - 1];
w4i = wtable_r[widx4];
int idx15 = in_off + i;
int idx16 = in_off + ic;
int idx17 = out_off + i;
int iidx1 = idx15 + idx2;
int iidx2 = idx16 + idx3;
int iidx3 = idx15 + idx4;
int iidx4 = idx16 + idx5;
int iidx5 = idx15 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
ti5 = i3r + i2r;
ti2 = i3r - i2r;
ti4 = i5r + i4r;
ti3 = i5r - i4r;
tr5 = i3i - i2i;
tr2 = i3i + i2i;
tr4 = i5i - i4i;
tr3 = i5i + i4i;
cr2 = i1i + tr11 * tr2 + tr12 * tr3;
ci2 = i1r + tr11 * ti2 + tr12 * ti3;
cr3 = i1i + tr12 * tr2 + tr11 * tr3;
ci3 = i1r + tr12 * ti2 + tr11 * ti3;
cr5 = ti11 * tr5 + ti12 * tr4;
ci5 = ti11 * ti5 + ti12 * ti4;
cr4 = ti12 * tr5 - ti11 * tr4;
ci4 = ti12 * ti5 - ti11 * ti4;
dr3 = cr3 - ci4;
dr4 = cr3 + ci4;
di3 = ci3 + cr4;
di4 = ci3 - cr4;
dr5 = cr2 + ci5;
dr2 = cr2 - ci5;
di5 = ci2 - cr5;
di2 = ci2 + cr5;
int oidx1 = idx17 + idx1;
int oidx2 = idx17 + idx7;
int oidx3 = idx17 + idx8;
int oidx4 = idx17 + idx9;
int oidx5 = idx17 + idx10;
out[oidx1 - 1] = i1i + tr2 + tr3;
out[oidx1] = i1r + ti2 + ti3;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
out[oidx4 - 1] = w3r * dr4 - w3i * di4;
out[oidx4] = w3r * di4 + w3i * dr4;
out[oidx5 - 1] = w4r * dr5 - w4i * di5;
out[oidx5] = w4r * di5 + w4i * dr5;
}
}
}
/*---------------------------------------------------------
radfg: Real FFT's forward processing of general factor
--------------------------------------------------------
void radfg(final int ido, final int ip, final int l1, final int idl1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int idij, ipph, j2, ic, jc, lc, is, nbd;
float dc2, ai1, ai2, ar1, ar2, ds2, dcp, arg, dsp, ar1h, ar2h, w1r, w1i;
int iw1 = offset;
arg = TWO_PI / (float) ip;
dcp = (float)Math.cos(arg);
dsp = (float)Math.sin(arg);
ipph = (ip + 1) / 2;
nbd = (ido - 1) / 2;
if (ido != 1) {
if (idl1 >= 0) System.arraycopy(in, in_off, out, out_off, idl1);
for (int j = 1; j < ip; j++) {
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx2 = k * ido + idx1;
out[out_off + idx2] = in[in_off + idx2];
}
}
if (nbd <= l1) {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
idij = is - 1;
int idx1 = j * l1 * ido;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
int idx4 = in_off + i;
int idx5 = out_off + i;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int oidx1 = idx5 + idx3;
int iidx1 = idx4 + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
out[oidx1 - 1] = w1r * i1i + w1i * i1r;
out[oidx1] = w1r * i1r - w1i * i1i;
}
}
}
} else {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
idij = is - 1;
int idx3 = k * ido + idx1;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
int oidx1 = out_off + i + idx3;
int iidx1 = in_off + i + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
out[oidx1 - 1] = w1r * i1i + w1i * i1r;
out[oidx1] = w1r * i1r - w1i * i1i;
}
}
}
}
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
for (int i = 2; i < ido; i += 2) {
int idx5 = in_off + i;
int idx6 = out_off + i;
int iidx1 = idx5 + idx3;
int iidx2 = idx5 + idx4;
int oidx1 = idx6 + idx3;
int oidx2 = idx6 + idx4;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx1] = o1r + o2r;
in[iidx2 - 1] = o1r - o2r;
in[iidx2] = o2i - o1i;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int i = 2; i < ido; i += 2) {
int idx5 = in_off + i;
int idx6 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
int iidx1 = idx5 + idx3;
int iidx2 = idx5 + idx4;
int oidx1 = idx6 + idx3;
int oidx2 = idx6 + idx4;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx1] = o1r + o2r;
in[iidx2 - 1] = o1r - o2r;
in[iidx2] = o2i - o1i;
}
}
}
}
} else {
System.arraycopy(out, out_off, in, in_off, idl1);
}
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
int oidx1 = out_off + idx3;
int oidx2 = out_off + idx4;
float o1r = out[oidx1];
float o2r = out[oidx2];
in[in_off + idx3] = o1r + o2r;
in[in_off + idx4] = o2r - o1r;
}
}
ar1 = 1;
ai1 = 0;
int idx0 = (ip - 1) * idl1;
for (int l = 1; l < ipph; l++) {
lc = ip - l;
ar1h = dcp * ar1 - dsp * ai1;
ai1 = dcp * ai1 + dsp * ar1;
ar1 = ar1h;
int idx1 = l * idl1;
int idx2 = lc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx3 = out_off + ik;
int idx4 = in_off + ik;
out[idx3 + idx1] = in[idx4] + ar1 * in[idx4 + idl1];
out[idx3 + idx2] = ai1 * in[idx4 + idx0];
}
dc2 = ar1;
ds2 = ai1;
ar2 = ar1;
ai2 = ai1;
for (int j = 2; j < ipph; j++) {
jc = ip - j;
ar2h = dc2 * ar2 - ds2 * ai2;
ai2 = dc2 * ai2 + ds2 * ar2;
ar2 = ar2h;
int idx3 = j * idl1;
int idx4 = jc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx5 = out_off + ik;
int idx6 = in_off + ik;
out[idx5 + idx1] += ar2 * in[idx6 + idx3];
out[idx5 + idx2] += ai2 * in[idx6 + idx4];
}
}
}
for (int j = 1; j < ipph; j++) {
int idx1 = j * idl1;
for (int ik = 0; ik < idl1; ik++) {
out[out_off + ik] += in[in_off + ik + idx1];
}
}
if (ido >= l1) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = idx1 * ip;
for (int i = 0; i < ido; i++) {
in[in_off + i + idx2] = out[out_off + i + idx1];
}
}
} else {
for (int i = 0; i < ido; i++) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
in[in_off + i + idx1 * ip] = out[out_off + i + idx1];
}
}
}
int idx01 = ip * ido;
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido;
int idx5 = idx4 + idx1;
int idx6 = idx4 + idx2;
int idx7 = k * idx01;
in[in_off + ido - 1 + idx3 - ido + idx7] = out[out_off + idx5];
in[in_off + idx3 + idx7] = out[out_off + idx6];
}
}
if (ido == 1)
return;
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * idx01;
int idx5 = k * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx6 = in_off + i;
int idx7 = in_off + ic;
int idx8 = out_off + i;
int iidx1 = idx6 + idx3 + idx4;
int iidx2 = idx7 + idx3 - ido + idx4;
int oidx1 = idx8 + idx5 + idx1;
int oidx2 = idx8 + idx5 + idx2;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx2 - 1] = o1i - o2i;
in[iidx1] = o1r + o2r;
in[iidx2] = o2r - o1r;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx6 = in_off + i;
int idx7 = in_off + ic;
int idx8 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx4 = k * idx01;
int idx5 = k * ido;
int iidx1 = idx6 + idx3 + idx4;
int iidx2 = idx7 + idx3 - ido + idx4;
int oidx1 = idx8 + idx5 + idx1;
int oidx2 = idx8 + idx5 + idx2;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx2 - 1] = o1i - o2i;
in[iidx1] = o1r + o2r;
in[iidx2] = o2r - o1r;
}
}
}
}
}
/*---------------------------------------------------------
radbg: Real FFT's backward processing of general factor
--------------------------------------------------------
void radbg(final int ido, final int ip, final int l1, final int idl1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int idij, ipph, j2, ic, jc, lc, is;
float dc2, ai1, ai2, ar1, ar2, ds2, w1r, w1i;
int nbd;
float dcp, arg, dsp, ar1h, ar2h;
int iw1 = offset;
arg = TWO_PI / (float) ip;
dcp = (float)Math.cos(arg);
dsp = (float)Math.sin(arg);
nbd = (ido - 1) / 2;
ipph = (ip + 1) / 2;
int idx0 = ip * ido;
if (ido >= l1) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = k * idx0;
for (int i = 0; i < ido; i++) {
out[out_off + i + idx1] = in[in_off + i + idx2];
}
}
} else {
for (int i = 0; i < ido; i++) {
int idx1 = out_off + i;
int idx2 = in_off + i;
for (int k = 0; k < l1; k++) {
out[idx1 + k * ido] = in[idx2 + k * idx0];
}
}
}
int iidx0 = in_off + ido - 1;
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido;
int idx5 = idx4 * ip;
int iidx1 = iidx0 + idx3 + idx5 - ido;
int iidx2 = in_off + idx3 + idx5;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[out_off + idx4 + idx1] = i1r + i1r;
out[out_off + idx4 + idx2] = i2r + i2r;
}
}
if (ido != 1) {
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = 2 * j * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido + idx1;
int idx5 = k * ido + idx2;
int idx6 = k * ip * ido + idx3;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = out_off + i;
int idx8 = in_off + ic;
int idx9 = in_off + i;
int oidx1 = idx7 + idx4;
int oidx2 = idx7 + idx5;
int iidx1 = idx9 + idx6;
int iidx2 = idx8 + idx6 - ido;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
out[oidx1 - 1] = a1i + a2i;
out[oidx2 - 1] = a1i - a2i;
out[oidx1] = a1r - a2r;
out[oidx2] = a1r + a2r;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = 2 * j * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = out_off + i;
int idx8 = in_off + ic;
int idx9 = in_off + i;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido + idx1;
int idx5 = k * ido + idx2;
int idx6 = k * ip * ido + idx3;
int oidx1 = idx7 + idx4;
int oidx2 = idx7 + idx5;
int iidx1 = idx9 + idx6;
int iidx2 = idx8 + idx6 - ido;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
out[oidx1 - 1] = a1i + a2i;
out[oidx2 - 1] = a1i - a2i;
out[oidx1] = a1r - a2r;
out[oidx2] = a1r + a2r;
}
}
}
}
}
ar1 = 1;
ai1 = 0;
int idx01 = (ip - 1) * idl1;
for (int l = 1; l < ipph; l++) {
lc = ip - l;
ar1h = dcp * ar1 - dsp * ai1;
ai1 = dcp * ai1 + dsp * ar1;
ar1 = ar1h;
int idx1 = l * idl1;
int idx2 = lc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx3 = in_off + ik;
int idx4 = out_off + ik;
in[idx3 + idx1] = out[idx4] + ar1 * out[idx4 + idl1];
in[idx3 + idx2] = ai1 * out[idx4 + idx01];
}
dc2 = ar1;
ds2 = ai1;
ar2 = ar1;
ai2 = ai1;
for (int j = 2; j < ipph; j++) {
jc = ip - j;
ar2h = dc2 * ar2 - ds2 * ai2;
ai2 = dc2 * ai2 + ds2 * ar2;
ar2 = ar2h;
int idx5 = j * idl1;
int idx6 = jc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx7 = in_off + ik;
int idx8 = out_off + ik;
in[idx7 + idx1] += ar2 * out[idx8 + idx5];
in[idx7 + idx2] += ai2 * out[idx8 + idx6];
}
}
}
for (int j = 1; j < ipph; j++) {
int idx1 = j * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx2 = out_off + ik;
out[idx2] += out[idx2 + idx1];
}
}
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int oidx1 = out_off + idx3;
int iidx1 = in_off + idx3 + idx1;
int iidx2 = in_off + idx3 + idx2;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1 + idx1] = i1r - i2r;
out[oidx1 + idx2] = i1r + i2r;
}
}
if (ido == 1)
return;
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
for (int i = 2; i < ido; i += 2) {
int idx4 = out_off + i;
int idx5 = in_off + i;
int oidx1 = idx4 + idx3 + idx1;
int oidx2 = idx4 + idx3 + idx2;
int iidx1 = idx5 + idx3 + idx1;
int iidx2 = idx5 + idx3 + idx2;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
out[oidx1 - 1] = i1i - i2r;
out[oidx2 - 1] = i1i + i2r;
out[oidx1] = i1r + i2i;
out[oidx2] = i1r - i2i;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int i = 2; i < ido; i += 2) {
int idx4 = out_off + i;
int idx5 = in_off + i;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int oidx1 = idx4 + idx3 + idx1;
int oidx2 = idx4 + idx3 + idx2;
int iidx1 = idx5 + idx3 + idx1;
int iidx2 = idx5 + idx3 + idx2;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
out[oidx1 - 1] = i1i - i2r;
out[oidx2 - 1] = i1i + i2r;
out[oidx1] = i1r + i2i;
out[oidx2] = i1r - i2i;
}
}
}
}
System.arraycopy(out, out_off, in, in_off, idl1);
for (int j = 1; j < ip; j++) {
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx2 = k * ido + idx1;
in[in_off + idx2] = out[out_off + idx2];
}
}
if (nbd <= l1) {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
idij = is - 1;
int idx1 = j * l1 * ido;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
int idx4 = in_off + i;
int idx5 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int iidx1 = idx4 + idx3;
int oidx1 = idx5 + idx3;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
in[iidx1 - 1] = w1r * o1i - w1i * o1r;
in[iidx1] = w1r * o1r + w1i * o1i;
}
}
}
} else {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
idij = is - 1;
int idx3 = k * ido + idx1;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
int idx4 = in_off + i;
int idx5 = out_off + i;
int iidx1 = idx4 + idx3;
int oidx1 = idx5 + idx3;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
in[iidx1 - 1] = w1r * o1i - w1i * o1r;
in[iidx1] = w1r * o1r + w1i * o1i;
}
}
}
}
}
/*---------------------------------------------------------
cfftf1: further processing of Complex forward FFT
--------------------------------------------------------
void cfftf(float[] a, int offa, int isign) {
int idot;
int l1, l2;
int na, nf, ip, iw, ido, idl1;
int[] nac = new int[1];
final int twon = 2 * n;
int iw1, iw2;
float[] ch = new float[twon];
iw1 = twon;
iw2 = 4 * n;
nac[0] = 0;
nf = (int) wtable[1 + iw2];
na = 0;
l1 = 1;
iw = iw1;
for (int k1 = 2; k1 <= nf + 1; k1++) {
ip = (int) wtable[k1 + iw2];
l2 = ip * l1;
ido = n / l2;
idot = ido + ido;
idl1 = idot * l1;
switch (ip) {
case 4:
if (na == 0) {
passf4(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf4(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
case 2:
if (na == 0) {
passf2(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf2(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
passf3(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf3(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
passf5(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf5(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
default:
if (na == 0) {
passfg(nac, idot, ip, l1, idl1, a, offa, ch, 0, iw, isign);
} else {
passfg(nac, idot, ip, l1, idl1, ch, 0, a, offa, iw, isign);
}
if (nac[0] != 0)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * idot;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, twon);
}
/*----------------------------------------------------------------------
passf2: Complex FFT's forward/backward processing of factor 2;
isign is +1 for backward and -1 for forward transforms
----------------------------------------------------------------------
void passf2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset, final int isign) {
float t1i, t1r;
int iw1;
iw1 = offset;
int idx = ido * l1;
if (ido <= 2) {
for (int k = 0; k < l1; k++) {
int idx0 = k * ido;
int iidx1 = in_off + 2 * idx0;
int iidx2 = iidx1 + ido;
float a1r = in[iidx1];
float a1i = in[iidx1 + 1];
float a2r = in[iidx2];
float a2i = in[iidx2 + 1];
int oidx1 = out_off + idx0;
int oidx2 = oidx1 + idx;
out[oidx1] = a1r + a2r;
out[oidx1 + 1] = a1i + a2i;
out[oidx2] = a1r - a2r;
out[oidx2 + 1] = a1i - a2i;
}
} else {
for (int k = 0; k < l1; k++) {
for (int i = 0; i < ido - 1; i += 2) {
int idx0 = k * ido;
int iidx1 = in_off + i + 2 * idx0;
int iidx2 = iidx1 + ido;
float i1r = in[iidx1];
float i1i = in[iidx1 + 1];
float i2r = in[iidx2];
float i2i = in[iidx2 + 1];
int widx1 = i + iw1;
float w1r = wtable[widx1];
float w1i = isign * wtable[widx1 + 1];
t1r = i1r - i2r;
t1i = i1i - i2i;
int oidx1 = out_off + i + idx0;
int oidx2 = oidx1 + idx;
out[oidx1] = i1r + i2r;
out[oidx1 + 1] = i1i + i2i;
out[oidx2] = w1r * t1r - w1i * t1i;
out[oidx2 + 1] = w1r * t1i + w1i * t1r;
}
}
}
}
/*----------------------------------------------------------------------
passf3: Complex FFT's forward/backward processing of factor 3;
isign is +1 for backward and -1 for forward transforms
---------------------------------------------------------------------- | FloatFFT::passf3 | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
void passf4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset, final int isign) {
float ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
if (ido == 2) {
for (int k = 0; k < l1; k++) {
int idxt1 = k * ido;
int iidx1 = in_off + 4 * idxt1 + 1;
int iidx2 = iidx1 + ido;
int iidx3 = iidx2 + ido;
int iidx4 = iidx3 + ido;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
ti1 = i1r - i3r;
ti2 = i1r + i3r;
tr4 = i4r - i2r;
ti3 = i2r + i4r;
tr1 = i1i - i3i;
tr2 = i1i + i3i;
ti4 = i2i - i4i;
tr3 = i2i + i4i;
int oidx1 = out_off + idxt1;
int oidx2 = oidx1 + idx0;
int oidx3 = oidx2 + idx0;
int oidx4 = oidx3 + idx0;
out[oidx1] = tr2 + tr3;
out[oidx1 + 1] = ti2 + ti3;
out[oidx2] = tr1 + isign * tr4;
out[oidx2 + 1] = ti1 + isign * ti4;
out[oidx3] = tr2 - tr3;
out[oidx3 + 1] = ti2 - ti3;
out[oidx4] = tr1 - isign * tr4;
out[oidx4 + 1] = ti1 - isign * ti4;
}
} else {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = in_off + 1 + 4 * idx1;
for (int i = 0; i < ido - 1; i += 2) {
int iidx1 = i + idx2;
int iidx2 = iidx1 + ido;
int iidx3 = iidx2 + ido;
int iidx4 = iidx3 + ido;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
ti1 = i1r - i3r;
ti2 = i1r + i3r;
ti3 = i2r + i4r;
tr4 = i4r - i2r;
tr1 = i1i - i3i;
tr2 = i1i + i3i;
ti4 = i2i - i4i;
tr3 = i2i + i4i;
cr3 = tr2 - tr3;
ci3 = ti2 - ti3;
cr2 = tr1 + isign * tr4;
cr4 = tr1 - isign * tr4;
ci2 = ti1 + isign * ti4;
ci4 = ti1 - isign * ti4;
int widx1 = i + iw1;
int widx2 = i + iw2;
int widx3 = i + iw3;
float w1r = wtable[widx1];
float w1i = isign * wtable[widx1 + 1];
float w2r = wtable[widx2];
float w2i = isign * wtable[widx2 + 1];
float w3r = wtable[widx3];
float w3i = isign * wtable[widx3 + 1];
int oidx1 = out_off + i + idx1;
int oidx2 = oidx1 + idx0;
int oidx3 = oidx2 + idx0;
int oidx4 = oidx3 + idx0;
out[oidx1] = tr2 + tr3;
out[oidx1 + 1] = ti2 + ti3;
out[oidx2] = w1r * cr2 - w1i * ci2;
out[oidx2 + 1] = w1r * ci2 + w1i * cr2;
out[oidx3] = w2r * cr3 - w2i * ci3;
out[oidx3 + 1] = w2r * ci3 + w2i * cr3;
out[oidx4] = w3r * cr4 - w3i * ci4;
out[oidx4 + 1] = w3r * ci4 + w3i * cr4;
}
}
}
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. This method computes the full real inverse transform, i.e. you will get
the same result as from <code>complexInverse</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
public void realInverseFull(final float[] a, final int offa, boolean scale) {
final int twon = 2 * n;
switch (plan) {
case SPLIT_RADIX:
realInverse2(a, offa, scale);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n / 2 > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
Future<?>[] futures = new Future[nthreads];
int k = n / 2 / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n / 2 : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
int idx1, idx2;
for (int k = firstIdx; k < lastIdx; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
int idx1, idx2;
for (int k = 0; k < n / 2; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
a[offa + n] = -a[offa + 1];
a[offa + 1] = 0;
break;
case MIXED_RADIX:
rfftf(a, offa);
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
} else {
m = (n + 1) / 2;
}
for (int k = 1; k < m; k++) {
int idx1 = offa + 2 * k;
int idx2 = offa + twon - 2 * k;
a[idx1] = -a[idx1];
a[idx2 + 1] = -a[idx1];
a[idx2] = a[idx1 - 1];
}
for (int k = 1; k < n; k++) {
int idx = offa + n - k;
float tmp = a[idx + 1];
a[idx + 1] = a[idx];
a[idx] = tmp;
}
a[offa + 1] = 0;
break;
case BLUESTEIN:
bluestein_real_full(a, offa, 1);
if (scale) {
scale(n, a, offa, true);
}
break;
}
}
private void realInverse2(float[] a, int offa, boolean scale) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
float xi;
if (n > 4) {
cftfsub(n, a, offa, ip, nw, w);
rftbsub(n, a, offa, nc, w, nw);
} else if (n == 4) {
cftbsub(n, a, offa, ip, nw, w);
}
xi = a[offa] - a[offa + 1];
a[offa] += a[offa + 1];
a[offa + 1] = xi;
if (scale) {
scale(n, a, offa, false);
}
break;
case MIXED_RADIX:
rfftf(a, offa);
for (int k = n - 1; k >= 2; k--) {
int idx = offa + k;
float tmp = a[idx];
a[idx] = a[idx - 1];
a[idx - 1] = tmp;
}
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
for (int i = 1; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
} else {
m = (n - 1) / 2;
for (int i = 0; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
}
break;
case BLUESTEIN:
bluestein_real_inverse2(a, offa);
if (scale) {
scale(n, a, offa, false);
}
break;
}
}
private static int getReminder(int n, int[] factors) {
int reminder = n;
if (n <= 0) {
throw new IllegalArgumentException("n must be positive integer");
}
for (int i = 0; i < factors.length && reminder != 1; i++) {
int factor = factors[i];
while ((reminder % factor) == 0) {
reminder /= factor;
}
}
return reminder;
}
/* -------- initializing routines --------
/*---------------------------------------------------------
cffti: initialization of Complex FFT
--------------------------------------------------------
void cffti(int n, int offw) {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[offw + nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[offw + idx + 1] = wtable[offw + idx];
}
wtable[offw + 2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[offw + fourn] = n;
wtable[offw + 1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[offw + k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[offw + i - 1 + twon] = 1;
wtable[offw + i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[offw + idx - 1] = (float)Math.cos(arg);
wtable[offw + idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[offw + idx1 - 1] = wtable[offw + idx2 - 1];
wtable[offw + idx1] = wtable[offw + idx2];
}
}
l1 = l2;
}
}
void cffti() {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[idx + 1] = wtable[idx];
}
wtable[2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[fourn] = n;
wtable[1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[i - 1 + twon] = 1;
wtable[i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[idx - 1] = (float)Math.cos(arg);
wtable[idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[idx1 - 1] = wtable[idx2 - 1];
wtable[idx1] = wtable[idx2];
}
}
l1 = l2;
}
}
void rffti() {
if (n == 1)
return;
final int twon = 2 * n;
float argh;
int ntry = 0, i, j;
float argld;
int k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, is, nq, nr;
float arg;
int ido, ipm;
int nfm1;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
++j;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
++nf;
wtable_r[nf + 1 + twon] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + twon;
wtable_r[idx + 1] = wtable_r[idx];
}
wtable_r[2 + twon] = 2;
}
} while (nl != 1);
break;
}
wtable_r[twon] = n;
wtable_r[1 + twon] = nf;
argh = TWO_PI / (float) (n);
is = 0;
nfm1 = nf - 1;
l1 = 1;
if (nfm1 == 0)
return;
for (k1 = 1; k1 <= nfm1; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
ipm = ip - 1;
for (j = 1; j <= ipm; ++j) {
ld += l1;
i = is;
argld = (float) ld * argh;
fi = 0;
for (ii = 3; ii <= ido; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + n;
wtable_r[idx - 2] = (float)Math.cos(arg);
wtable_r[idx - 1] = (float)Math.sin(arg);
}
is += ido;
}
l1 = l2;
}
}
private void bluesteini() {
int k = 0;
float arg;
float pi_n = PI / n;
bk1[0] = 1;
bk1[1] = 0;
for (int i = 1; i < n; i++) {
k += 2 * i - 1;
if (k >= 2 * n)
k -= 2 * n;
arg = pi_n * k;
bk1[2 * i] = (float)Math.cos(arg);
bk1[2 * i + 1] = (float)Math.sin(arg);
}
float scale = (float)(1.0 / nBluestein);
bk2[0] = bk1[0] * scale;
bk2[1] = bk1[1] * scale;
for (int i = 2; i < 2 * n; i += 2) {
bk2[i] = bk1[i] * scale;
bk2[i + 1] = bk1[i + 1] * scale;
bk2[2 * nBluestein - i] = bk2[i];
bk2[2 * nBluestein - i + 1] = bk2[i + 1];
}
cftbsub(2 * nBluestein, bk2, 0, ip, nw, w);
}
private void makewt(int nw) {
int j, nwh, nw0, nw1;
float delta, wn4r, wk1r, wk1i, wk3r, wk3i;
float delta2, deltaj, deltaj3;
ip[0] = nw;
ip[1] = 1;
if (nw > 2) {
nwh = nw >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nwh);
delta2 = delta * 2;
wn4r = (float)Math.cos(delta * nwh);
w[0] = 1;
w[1] = wn4r;
if (nwh == 4) {
w[2] = (float)Math.cos(delta2);
w[3] = (float)Math.sin(delta2);
} else if (nwh > 4) {
makeipt(nw);
w[2] = (float)(0.5 / Math.cos(delta2));
w[3] = (float)(0.5 / Math.cos(delta * 6));
for (j = 4; j < nwh; j += 4) {
deltaj = delta * j;
deltaj3 = 3 * deltaj;
w[j] = (float)Math.cos(deltaj);
w[j + 1] = (float)Math.sin(deltaj);
w[j + 2] = (float)Math.cos(deltaj3);
w[j + 3] = (float)-Math.sin(deltaj3);
}
}
nw0 = 0;
while (nwh > 2) {
nw1 = nw0 + nwh;
nwh >>= 1;
w[nw1] = 1;
w[nw1 + 1] = wn4r;
if (nwh == 4) {
wk1r = w[nw0 + 4];
wk1i = w[nw0 + 5];
w[nw1 + 2] = wk1r;
w[nw1 + 3] = wk1i;
} else if (nwh > 4) {
wk1r = w[nw0 + 4];
wk3r = w[nw0 + 6];
w[nw1 + 2] = (float)(0.5 / wk1r);
w[nw1 + 3] = (float)(0.5 / wk3r);
for (j = 4; j < nwh; j += 4) {
int idx1 = nw0 + 2 * j;
int idx2 = nw1 + j;
wk1r = w[idx1];
wk1i = w[idx1 + 1];
wk3r = w[idx1 + 2];
wk3i = w[idx1 + 3];
w[idx2] = wk1r;
w[idx2 + 1] = wk1i;
w[idx2 + 2] = wk3r;
w[idx2 + 3] = wk3i;
}
}
nw0 = nw1;
}
}
}
private void makeipt(int nw) {
int j, l, m, m2, p, q;
ip[2] = 0;
ip[3] = 16;
m = 2;
for (l = nw; l > 32; l >>= 2) {
m2 = m << 1;
q = m2 << 3;
for (j = m; j < m2; j++) {
p = ip[j] << 2;
ip[m + j] = p;
ip[m2 + j] = p + q;
}
m = m2;
}
}
private void makect(int nc, float[] c, int startc) {
int j, nch;
float delta, deltaj;
ip[1] = nc;
if (nc > 1) {
nch = nc >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nch);
c[startc] = (float)Math.cos(delta * nch);
c[startc + nch] = (float)(0.5 * c[startc]);
for (j = 1; j < nch; j++) {
deltaj = delta * j;
c[startc + j] = (float)(0.5 * Math.cos(deltaj));
c[startc + nc - j] = (float)(0.5 * Math.sin(deltaj));
}
}
}
private void bluestein_complex(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_full(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_forward(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] + bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = -bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] + bk1[n] * ak[n];
}
}
private void bluestein_real_inverse(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
if (n % 2 == 0) {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n] = a[offa + 1] * bk1[n];
ak[n + 1] = a[offa + 1] * bk1[n + 1];
for (int i = n / 2 + 1; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
} else {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n - 1] = a[offa + n - 1] * bk1[n - 1] - a[offa + 1] * bk1[n];
ak[n] = a[offa + n - 1] * bk1[n] + a[offa + 1] * bk1[n - 1];
ak[n + 1] = a[offa + n - 1] * bk1[n + 1] + a[offa + 1] * bk1[n + 2];
ak[n + 2] = a[offa + n - 1] * bk1[n + 2] - a[offa + 1] * bk1[n + 1];
for (int i = (n - 1) / 2 + 2; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
}
private void bluestein_real_inverse2(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] - bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] - bk1[n] * ak[n];
}
}
/*---------------------------------------------------------
rfftf1: further processing of Real forward FFT
--------------------------------------------------------
void rfftf(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, kh, nf, ip, iw, ido, idl1;
final float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 1;
l2 = n;
iw = twon - 1;
for (int k1 = 1; k1 <= nf; ++k1) {
kh = nf - k1;
ip = (int) wtable_r[kh + 2 + twon];
l1 = l2 / ip;
ido = n / l2;
idl1 = ido * l1;
iw -= (ip - 1) * ido;
na = 1 - na;
switch (ip) {
case 2:
if (na == 0) {
radf2(ido, l1, a, offa, ch, 0, iw);
} else {
radf2(ido, l1, ch, 0, a, offa, iw);
}
break;
case 3:
if (na == 0) {
radf3(ido, l1, a, offa, ch, 0, iw);
} else {
radf3(ido, l1, ch, 0, a, offa, iw);
}
break;
case 4:
if (na == 0) {
radf4(ido, l1, a, offa, ch, 0, iw);
} else {
radf4(ido, l1, ch, 0, a, offa, iw);
}
break;
case 5:
if (na == 0) {
radf5(ido, l1, a, offa, ch, 0, iw);
} else {
radf5(ido, l1, ch, 0, a, offa, iw);
}
break;
default:
if (ido == 1)
na = 1 - na;
if (na == 0) {
radfg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
na = 1;
} else {
radfg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
na = 0;
}
break;
}
l2 = l1;
}
if (na == 1)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*---------------------------------------------------------
rfftb1: further processing of Real backward FFT
--------------------------------------------------------
void rfftb(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, nf, ip, iw, ido, idl1;
float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 0;
l1 = 1;
iw = n;
for (int k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
l2 = ip * l1;
ido = n / l2;
idl1 = ido * l1;
switch (ip) {
case 2:
if (na == 0) {
radb2(ido, l1, a, offa, ch, 0, iw);
} else {
radb2(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
radb3(ido, l1, a, offa, ch, 0, iw);
} else {
radb3(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 4:
if (na == 0) {
radb4(ido, l1, a, offa, ch, 0, iw);
} else {
radb4(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
radb5(ido, l1, a, offa, ch, 0, iw);
} else {
radb5(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
default:
if (na == 0) {
radbg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
} else {
radbg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
}
if (ido == 1)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * ido;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*-------------------------------------------------
radf2: Real FFT's forward processing of factor 2
-------------------------------------------------
void radf2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic, idx0, idx1, idx2, idx3, idx4;
float t1i, t1r, w1r, w1i;
int iw1;
iw1 = offset;
idx0 = l1 * ido;
idx1 = 2 * ido;
for (int k = 0; k < l1; k++) {
int oidx1 = out_off + k * idx1;
int oidx2 = oidx1 + idx1 - 1;
int iidx1 = in_off + k * ido;
int iidx2 = iidx1 + idx0;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx2] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
idx2 = 2 * idx1;
idx3 = idx2 + ido;
idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int oidx1 = out_off + i + idx2;
int oidx2 = out_off + ic + idx3;
int iidx1 = in_off + i + idx1;
int iidx2 = in_off + i + idx4;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
t1r = w1r * a2i + w1i * a2r;
t1i = w1r * a2r - w1i * a2i;
out[oidx1] = a1r + t1i;
out[oidx1 - 1] = a1i + t1r;
out[oidx2] = t1i - a1r;
out[oidx2 - 1] = a1i - t1r;
}
}
if (ido % 2 == 1)
return;
}
idx2 = 2 * idx1;
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
int oidx1 = out_off + idx2 + ido;
int iidx1 = in_off + ido - 1 + idx1;
out[oidx1] = -in[iidx1 + idx0];
out[oidx1 - 1] = in[iidx1];
}
}
/*-------------------------------------------------
radb2: Real FFT's backward processing of factor 2
-------------------------------------------------
void radb2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic;
float t1i, t1r, w1r, w1i;
int iw1 = offset;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int oidx1 = out_off + idx1;
int iidx1 = in_off + idx2;
int iidx2 = in_off + ido - 1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx1 + idx0] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx5 = i - 1 + iw1;
int idx6 = out_off + i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
w1r = wtable_r[idx5 - 1];
w1i = wtable_r[idx5];
int iidx1 = idx7 + idx2;
int iidx2 = idx8 + idx3;
int oidx1 = idx6 + idx1;
int oidx2 = idx6 + idx4;
t1r = in[iidx1 - 1] - in[iidx2 - 1];
t1i = in[iidx1] + in[iidx2];
float i1i = in[iidx1];
float i1r = in[iidx1 - 1];
float i2i = in[iidx2];
float i2r = in[iidx2 - 1];
out[oidx1 - 1] = i1r + i2r;
out[oidx1] = i1i - i2i;
out[oidx2 - 1] = w1r * t1r - w1i * t1i;
out[oidx2] = w1r * t1i + w1i * t1r;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int oidx1 = out_off + ido - 1 + idx1;
int iidx1 = in_off + idx2 + ido;
out[oidx1] = 2 * in[iidx1 - 1];
out[oidx1 + idx0] = -2 * in[iidx1];
}
}
/*-------------------------------------------------
radf3: Real FFT's forward processing of factor 3
-------------------------------------------------
void radf3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, di2, di3, cr2, dr2, dr3, ti2, ti3, tr2, tr3, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx3 = 2 * idx0;
int idx4 = (3 * k + 1) * ido;
int iidx1 = in_off + idx1;
int iidx2 = iidx1 + idx0;
int iidx3 = iidx1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
float i3r = in[iidx3];
cr2 = i2r + i3r;
out[out_off + 3 * idx1] = i1r + cr2;
out[out_off + idx4 + ido] = taui * (i3r - i2r);
out[out_off + ido - 1 + idx4] = i1r + taur * cr2;
}
if (ido == 1)
return;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int idx4 = 3 * idx3;
int idx5 = idx3 + idx0;
int idx6 = idx5 + idx0;
int idx7 = idx4 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx3;
int iidx2 = idx9 + idx5;
int iidx3 = idx9 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
cr2 = dr2 + dr3;
ci2 = di2 + di3;
tr2 = i1i + taur * cr2;
ti2 = i1r + taur * ci2;
tr3 = taui * (di2 - di3);
ti3 = taui * (dr3 - dr2);
int oidx1 = idx10 + idx4;
int oidx2 = idx11 + idx7;
int oidx3 = idx10 + idx8;
out[oidx1 - 1] = i1i + cr2;
out[oidx1] = i1r + ci2;
out[oidx2 - 1] = tr2 - tr3;
out[oidx2] = ti3 - ti2;
out[oidx3 - 1] = tr2 + tr3;
out[oidx3] = ti2 + ti3;
}
}
}
/*-------------------------------------------------
radb3: Real FFT's backward processing of factor 3
-------------------------------------------------
void radb3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, ci3, di2, di3, cr2, cr3, dr2, dr3, ti2, tr2, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int iidx1 = in_off + 3 * idx1;
int iidx2 = iidx1 + 2 * ido;
float i1i = in[iidx1];
tr2 = 2 * in[iidx2 - 1];
cr2 = i1i + taur * tr2;
ci3 = 2 * taui * in[iidx2];
out[out_off + idx1] = i1i + tr2;
out[out_off + (k + l1) * ido] = cr2 - ci3;
out[out_off + (k + 2 * l1) * ido] = cr2 + ci3;
}
if (ido == 1)
return;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 3 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx1 + idx0;
int idx6 = idx5 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
int idx9 = out_off + i;
int iidx1 = idx7 + idx2;
int iidx2 = idx7 + idx4;
int iidx3 = idx8 + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
tr2 = i2i + i3i;
cr2 = i1i + taur * tr2;
ti2 = i2r - i3r;
ci2 = i1r + taur * ti2;
cr3 = taui * (i2i - i3i);
ci3 = taui * (i2r + i3r);
dr2 = cr2 - ci3;
dr3 = cr2 + ci3;
di2 = ci2 + cr3;
di3 = ci2 - cr3;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int oidx1 = idx9 + idx1;
int oidx2 = idx9 + idx5;
int oidx3 = idx9 + idx6;
out[oidx1 - 1] = i1i + tr2;
out[oidx1] = i1r + ti2;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
}
}
}
/*-------------------------------------------------
radf4: Real FFT's forward processing of factor 4
-------------------------------------------------
void radf4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float hsqt2 = 0.707106781186547572737310929369414225f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = offset + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx3];
float i3r = in[in_off + idx4];
float i4r = in[in_off + idx5];
tr1 = i2r + i4r;
tr2 = i1r + i3r;
int oidx1 = out_off + idx2;
int oidx2 = out_off + idx6 + ido;
out[oidx1] = tr1 + tr2;
out[oidx2 - 1 + ido + ido] = tr2 - tr1;
out[oidx2 - 1] = i1r - i3r;
out[oidx2] = i4r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx1;
int iidx2 = idx9 + idx2;
int iidx3 = idx9 + idx3;
int iidx4 = idx9 + idx4;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
cr2 = w1r * i2i + w1i * i2r;
ci2 = w1r * i2r - w1i * i2i;
cr3 = w2r * i3i + w2i * i3r;
ci3 = w2r * i3r - w2i * i3i;
cr4 = w3r * i4i + w3i * i4r;
ci4 = w3r * i4r - w3i * i4i;
tr1 = cr2 + cr4;
tr4 = cr4 - cr2;
ti1 = ci2 + ci4;
ti4 = ci2 - ci4;
ti2 = i1r + ci3;
ti3 = i1r - ci3;
tr2 = i1i + cr3;
tr3 = i1i - cr3;
int oidx1 = idx10 + idx5;
int oidx2 = idx11 + idx6;
int oidx3 = idx10 + idx7;
int oidx4 = idx11 + idx8;
out[oidx1 - 1] = tr1 + tr2;
out[oidx4 - 1] = tr2 - tr1;
out[oidx1] = ti1 + ti2;
out[oidx4] = ti1 - ti2;
out[oidx3 - 1] = ti4 + tr3;
out[oidx2 - 1] = tr3 - ti4;
out[oidx3] = tr4 + ti3;
out[oidx2] = tr4 - ti3;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1i = in[idx9 - 1 + idx1];
float i2i = in[idx9 - 1 + idx3];
float i3i = in[idx9 - 1 + idx4];
float i4i = in[idx9 - 1 + idx5];
ti1 = -hsqt2 * (i2i + i4i);
tr1 = hsqt2 * (i2i - i4i);
out[idx10 - 1 + idx2] = tr1 + i1i;
out[idx10 - 1 + idx7] = i1i - tr1;
out[out_off + idx6] = ti1 - i3i;
out[out_off + idx8] = ti1 + i3i;
}
}
/*-------------------------------------------------
radb4: Real FFT's backward processing of factor 4
-------------------------------------------------
void radb4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float sqrt2 = 1.41421356237309514547462185873882845f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4;
float ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
float i1r = in[in_off + idx2];
float i2r = in[in_off + idx7];
float i3r = in[in_off + ido - 1 + idx8];
float i4r = in[in_off + ido - 1 + idx6];
tr1 = i1r - i3r;
tr2 = i1r + i3r;
tr3 = i4r + i4r;
tr4 = i2r + i2r;
out[out_off + idx1] = tr2 + tr3;
out[out_off + idx3] = tr1 - tr4;
out[out_off + idx4] = tr2 - tr3;
out[out_off + idx5] = tr1 + tr4;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx12 = in_off + i;
int idx13 = in_off + ic;
int idx14 = out_off + i;
int iidx1 = idx12 + idx5;
int iidx2 = idx13 + idx6;
int iidx3 = idx12 + idx7;
int iidx4 = idx13 + idx8;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
ti1 = i1r + i4r;
ti2 = i1r - i4r;
ti3 = i3r - i2r;
tr4 = i3r + i2r;
tr1 = i1i - i4i;
tr2 = i1i + i4i;
ti4 = i3i - i2i;
tr3 = i3i + i2i;
cr3 = tr2 - tr3;
ci3 = ti2 - ti3;
cr2 = tr1 - tr4;
cr4 = tr1 + tr4;
ci2 = ti1 + ti4;
ci4 = ti1 - ti4;
int oidx1 = idx14 + idx1;
int oidx2 = idx14 + idx2;
int oidx3 = idx14 + idx3;
int oidx4 = idx14 + idx4;
out[oidx1 - 1] = tr2 + tr3;
out[oidx1] = ti2 + ti3;
out[oidx2 - 1] = w1r * cr2 - w1i * ci2;
out[oidx2] = w1r * ci2 + w1i * cr2;
out[oidx3 - 1] = w2r * cr3 - w2i * ci3;
out[oidx3] = w2r * ci3 + w2i * cr3;
out[oidx4 - 1] = w3r * cr4 - w3i * ci4;
out[oidx4] = w3r * ci4 + w3i * cr4;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1r = in[idx9 - 1 + idx2];
float i2r = in[idx9 - 1 + idx7];
float i3r = in[in_off + idx6];
float i4r = in[in_off + idx8];
ti1 = i3r + i4r;
ti2 = i4r - i3r;
tr1 = i1r - i2r;
tr2 = i1r + i2r;
out[idx10 - 1 + idx1] = tr2 + tr2;
out[idx10 - 1 + idx3] = sqrt2 * (tr1 - ti1);
out[idx10 - 1 + idx4] = ti2 + ti2;
out[idx10 - 1 + idx5] = -sqrt2 * (tr1 + ti1);
}
}
/*-------------------------------------------------
radf5: Real FFT's forward processing of factor 5
-------------------------------------------------
void radf5(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float tr11 = 0.309016994374947451262869435595348477f;
final float ti11 = 0.951056516295153531181938433292089030f;
final float tr12 = -0.809016994374947340240566973079694435f;
final float ti12 = 0.587785252292473248125759255344746634f;
int i, ic;
float ci2, di2, ci4, ci5, di3, di4, di5, ci3, cr2, cr3, dr2, dr3, dr4, dr5, cr5, cr4, ti2, ti3, ti5, ti4, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
int iw1, iw2, iw3, iw4;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
iw4 = iw3 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
int idx11 = out_off + ido - 1;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx7];
float i3r = in[in_off + idx8];
float i4r = in[in_off + idx9];
float i5r = in[in_off + idx10];
cr2 = i5r + i2r;
ci5 = i5r - i2r;
cr3 = i4r + i3r;
ci4 = i4r - i3r;
out[out_off + idx2] = i1r + cr2 + cr3;
out[idx11 + idx3] = i1r + tr11 * cr2 + tr12 * cr3;
out[out_off + idx4] = ti11 * ci5 + ti12 * ci4;
out[idx11 + idx5] = i1r + tr12 * cr2 + tr11 * cr3;
out[out_off + idx6] = ti12 * ci5 - ti11 * ci4;
}
if (ido == 1)
return;
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
for (i = 2; i < ido; i += 2) {
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
int widx4 = i - 1 + iw4;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
w4r = wtable_r[widx4 - 1];
w4i = wtable_r[widx4];
ic = ido - i;
int idx15 = in_off + i;
int idx16 = out_off + i;
int idx17 = out_off + ic;
int iidx1 = idx15 + idx1;
int iidx2 = idx15 + idx7;
int iidx3 = idx15 + idx8;
int iidx4 = idx15 + idx9;
int iidx5 = idx15 + idx10;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
dr4 = w3r * i4i + w3i * i4r;
di4 = w3r * i4r - w3i * i4i;
dr5 = w4r * i5i + w4i * i5r;
di5 = w4r * i5r - w4i * i5i;
cr2 = dr2 + dr5;
ci5 = dr5 - dr2;
cr5 = di2 - di5;
ci2 = di2 + di5;
cr3 = dr3 + dr4;
ci4 = dr4 - dr3;
cr4 = di3 - di4;
ci3 = di3 + di4;
tr2 = i1i + tr11 * cr2 + tr12 * cr3;
ti2 = i1r + tr11 * ci2 + tr12 * ci3;
tr3 = i1i + tr12 * cr2 + tr11 * cr3;
ti3 = i1r + tr12 * ci2 + tr11 * ci3;
tr5 = ti11 * cr5 + ti12 * cr4;
ti5 = ti11 * ci5 + ti12 * ci4;
tr4 = ti12 * cr5 - ti11 * cr4;
ti4 = ti12 * ci5 - ti11 * ci4;
int oidx1 = idx16 + idx2;
int oidx2 = idx17 + idx3;
int oidx3 = idx16 + idx4;
int oidx4 = idx17 + idx5;
int oidx5 = idx16 + idx6;
out[oidx1 - 1] = i1i + cr2 + cr3;
out[oidx1] = i1r + ci2 + ci3;
out[oidx3 - 1] = tr2 + tr5;
out[oidx2 - 1] = tr2 - tr5;
out[oidx3] = ti2 + ti5;
out[oidx2] = ti5 - ti2;
out[oidx5 - 1] = tr3 + tr4;
out[oidx4 - 1] = tr3 - tr4;
out[oidx5] = ti3 + ti4;
out[oidx4] = ti4 - ti3;
}
}
}
/*-------------------------------------------------
radb5: Real FFT's backward processing of factor 5
-------------------------------------------------
void radb5(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float tr11 = 0.309016994374947451262869435595348477f;
final float ti11 = 0.951056516295153531181938433292089030f;
final float tr12 = -0.809016994374947340240566973079694435f;
final float ti12 = 0.587785252292473248125759255344746634f;
int i, ic;
float ci2, ci3, ci4, ci5, di3, di4, di5, di2, cr2, cr3, cr5, cr4, ti2, ti3, ti4, ti5, dr3, dr4, dr5, dr2, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
int iw1, iw2, iw3, iw4;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
iw4 = iw3 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
int idx11 = in_off + ido - 1;
float i1r = in[in_off + idx2];
ti5 = 2 * in[in_off + idx4];
ti4 = 2 * in[in_off + idx6];
tr2 = 2 * in[idx11 + idx3];
tr3 = 2 * in[idx11 + idx5];
cr2 = i1r + tr11 * tr2 + tr12 * tr3;
cr3 = i1r + tr12 * tr2 + tr11 * tr3;
ci5 = ti11 * ti5 + ti12 * ti4;
ci4 = ti12 * ti5 - ti11 * ti4;
out[out_off + idx1] = i1r + tr2 + tr3;
out[out_off + idx7] = cr2 - ci5;
out[out_off + idx8] = cr3 - ci4;
out[out_off + idx9] = cr3 + ci4;
out[out_off + idx10] = cr2 + ci5;
}
if (ido == 1)
return;
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
int widx4 = i - 1 + iw4;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
w4r = wtable_r[widx4 - 1];
w4i = wtable_r[widx4];
int idx15 = in_off + i;
int idx16 = in_off + ic;
int idx17 = out_off + i;
int iidx1 = idx15 + idx2;
int iidx2 = idx16 + idx3;
int iidx3 = idx15 + idx4;
int iidx4 = idx16 + idx5;
int iidx5 = idx15 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
ti5 = i3r + i2r;
ti2 = i3r - i2r;
ti4 = i5r + i4r;
ti3 = i5r - i4r;
tr5 = i3i - i2i;
tr2 = i3i + i2i;
tr4 = i5i - i4i;
tr3 = i5i + i4i;
cr2 = i1i + tr11 * tr2 + tr12 * tr3;
ci2 = i1r + tr11 * ti2 + tr12 * ti3;
cr3 = i1i + tr12 * tr2 + tr11 * tr3;
ci3 = i1r + tr12 * ti2 + tr11 * ti3;
cr5 = ti11 * tr5 + ti12 * tr4;
ci5 = ti11 * ti5 + ti12 * ti4;
cr4 = ti12 * tr5 - ti11 * tr4;
ci4 = ti12 * ti5 - ti11 * ti4;
dr3 = cr3 - ci4;
dr4 = cr3 + ci4;
di3 = ci3 + cr4;
di4 = ci3 - cr4;
dr5 = cr2 + ci5;
dr2 = cr2 - ci5;
di5 = ci2 - cr5;
di2 = ci2 + cr5;
int oidx1 = idx17 + idx1;
int oidx2 = idx17 + idx7;
int oidx3 = idx17 + idx8;
int oidx4 = idx17 + idx9;
int oidx5 = idx17 + idx10;
out[oidx1 - 1] = i1i + tr2 + tr3;
out[oidx1] = i1r + ti2 + ti3;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
out[oidx4 - 1] = w3r * dr4 - w3i * di4;
out[oidx4] = w3r * di4 + w3i * dr4;
out[oidx5 - 1] = w4r * dr5 - w4i * di5;
out[oidx5] = w4r * di5 + w4i * dr5;
}
}
}
/*---------------------------------------------------------
radfg: Real FFT's forward processing of general factor
--------------------------------------------------------
void radfg(final int ido, final int ip, final int l1, final int idl1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int idij, ipph, j2, ic, jc, lc, is, nbd;
float dc2, ai1, ai2, ar1, ar2, ds2, dcp, arg, dsp, ar1h, ar2h, w1r, w1i;
int iw1 = offset;
arg = TWO_PI / (float) ip;
dcp = (float)Math.cos(arg);
dsp = (float)Math.sin(arg);
ipph = (ip + 1) / 2;
nbd = (ido - 1) / 2;
if (ido != 1) {
if (idl1 >= 0) System.arraycopy(in, in_off, out, out_off, idl1);
for (int j = 1; j < ip; j++) {
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx2 = k * ido + idx1;
out[out_off + idx2] = in[in_off + idx2];
}
}
if (nbd <= l1) {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
idij = is - 1;
int idx1 = j * l1 * ido;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
int idx4 = in_off + i;
int idx5 = out_off + i;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int oidx1 = idx5 + idx3;
int iidx1 = idx4 + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
out[oidx1 - 1] = w1r * i1i + w1i * i1r;
out[oidx1] = w1r * i1r - w1i * i1i;
}
}
}
} else {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
idij = is - 1;
int idx3 = k * ido + idx1;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
int oidx1 = out_off + i + idx3;
int iidx1 = in_off + i + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
out[oidx1 - 1] = w1r * i1i + w1i * i1r;
out[oidx1] = w1r * i1r - w1i * i1i;
}
}
}
}
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
for (int i = 2; i < ido; i += 2) {
int idx5 = in_off + i;
int idx6 = out_off + i;
int iidx1 = idx5 + idx3;
int iidx2 = idx5 + idx4;
int oidx1 = idx6 + idx3;
int oidx2 = idx6 + idx4;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx1] = o1r + o2r;
in[iidx2 - 1] = o1r - o2r;
in[iidx2] = o2i - o1i;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int i = 2; i < ido; i += 2) {
int idx5 = in_off + i;
int idx6 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
int iidx1 = idx5 + idx3;
int iidx2 = idx5 + idx4;
int oidx1 = idx6 + idx3;
int oidx2 = idx6 + idx4;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx1] = o1r + o2r;
in[iidx2 - 1] = o1r - o2r;
in[iidx2] = o2i - o1i;
}
}
}
}
} else {
System.arraycopy(out, out_off, in, in_off, idl1);
}
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
int oidx1 = out_off + idx3;
int oidx2 = out_off + idx4;
float o1r = out[oidx1];
float o2r = out[oidx2];
in[in_off + idx3] = o1r + o2r;
in[in_off + idx4] = o2r - o1r;
}
}
ar1 = 1;
ai1 = 0;
int idx0 = (ip - 1) * idl1;
for (int l = 1; l < ipph; l++) {
lc = ip - l;
ar1h = dcp * ar1 - dsp * ai1;
ai1 = dcp * ai1 + dsp * ar1;
ar1 = ar1h;
int idx1 = l * idl1;
int idx2 = lc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx3 = out_off + ik;
int idx4 = in_off + ik;
out[idx3 + idx1] = in[idx4] + ar1 * in[idx4 + idl1];
out[idx3 + idx2] = ai1 * in[idx4 + idx0];
}
dc2 = ar1;
ds2 = ai1;
ar2 = ar1;
ai2 = ai1;
for (int j = 2; j < ipph; j++) {
jc = ip - j;
ar2h = dc2 * ar2 - ds2 * ai2;
ai2 = dc2 * ai2 + ds2 * ar2;
ar2 = ar2h;
int idx3 = j * idl1;
int idx4 = jc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx5 = out_off + ik;
int idx6 = in_off + ik;
out[idx5 + idx1] += ar2 * in[idx6 + idx3];
out[idx5 + idx2] += ai2 * in[idx6 + idx4];
}
}
}
for (int j = 1; j < ipph; j++) {
int idx1 = j * idl1;
for (int ik = 0; ik < idl1; ik++) {
out[out_off + ik] += in[in_off + ik + idx1];
}
}
if (ido >= l1) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = idx1 * ip;
for (int i = 0; i < ido; i++) {
in[in_off + i + idx2] = out[out_off + i + idx1];
}
}
} else {
for (int i = 0; i < ido; i++) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
in[in_off + i + idx1 * ip] = out[out_off + i + idx1];
}
}
}
int idx01 = ip * ido;
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido;
int idx5 = idx4 + idx1;
int idx6 = idx4 + idx2;
int idx7 = k * idx01;
in[in_off + ido - 1 + idx3 - ido + idx7] = out[out_off + idx5];
in[in_off + idx3 + idx7] = out[out_off + idx6];
}
}
if (ido == 1)
return;
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * idx01;
int idx5 = k * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx6 = in_off + i;
int idx7 = in_off + ic;
int idx8 = out_off + i;
int iidx1 = idx6 + idx3 + idx4;
int iidx2 = idx7 + idx3 - ido + idx4;
int oidx1 = idx8 + idx5 + idx1;
int oidx2 = idx8 + idx5 + idx2;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx2 - 1] = o1i - o2i;
in[iidx1] = o1r + o2r;
in[iidx2] = o2r - o1r;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx6 = in_off + i;
int idx7 = in_off + ic;
int idx8 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx4 = k * idx01;
int idx5 = k * ido;
int iidx1 = idx6 + idx3 + idx4;
int iidx2 = idx7 + idx3 - ido + idx4;
int oidx1 = idx8 + idx5 + idx1;
int oidx2 = idx8 + idx5 + idx2;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx2 - 1] = o1i - o2i;
in[iidx1] = o1r + o2r;
in[iidx2] = o2r - o1r;
}
}
}
}
}
/*---------------------------------------------------------
radbg: Real FFT's backward processing of general factor
--------------------------------------------------------
void radbg(final int ido, final int ip, final int l1, final int idl1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int idij, ipph, j2, ic, jc, lc, is;
float dc2, ai1, ai2, ar1, ar2, ds2, w1r, w1i;
int nbd;
float dcp, arg, dsp, ar1h, ar2h;
int iw1 = offset;
arg = TWO_PI / (float) ip;
dcp = (float)Math.cos(arg);
dsp = (float)Math.sin(arg);
nbd = (ido - 1) / 2;
ipph = (ip + 1) / 2;
int idx0 = ip * ido;
if (ido >= l1) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = k * idx0;
for (int i = 0; i < ido; i++) {
out[out_off + i + idx1] = in[in_off + i + idx2];
}
}
} else {
for (int i = 0; i < ido; i++) {
int idx1 = out_off + i;
int idx2 = in_off + i;
for (int k = 0; k < l1; k++) {
out[idx1 + k * ido] = in[idx2 + k * idx0];
}
}
}
int iidx0 = in_off + ido - 1;
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido;
int idx5 = idx4 * ip;
int iidx1 = iidx0 + idx3 + idx5 - ido;
int iidx2 = in_off + idx3 + idx5;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[out_off + idx4 + idx1] = i1r + i1r;
out[out_off + idx4 + idx2] = i2r + i2r;
}
}
if (ido != 1) {
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = 2 * j * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido + idx1;
int idx5 = k * ido + idx2;
int idx6 = k * ip * ido + idx3;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = out_off + i;
int idx8 = in_off + ic;
int idx9 = in_off + i;
int oidx1 = idx7 + idx4;
int oidx2 = idx7 + idx5;
int iidx1 = idx9 + idx6;
int iidx2 = idx8 + idx6 - ido;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
out[oidx1 - 1] = a1i + a2i;
out[oidx2 - 1] = a1i - a2i;
out[oidx1] = a1r - a2r;
out[oidx2] = a1r + a2r;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = 2 * j * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = out_off + i;
int idx8 = in_off + ic;
int idx9 = in_off + i;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido + idx1;
int idx5 = k * ido + idx2;
int idx6 = k * ip * ido + idx3;
int oidx1 = idx7 + idx4;
int oidx2 = idx7 + idx5;
int iidx1 = idx9 + idx6;
int iidx2 = idx8 + idx6 - ido;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
out[oidx1 - 1] = a1i + a2i;
out[oidx2 - 1] = a1i - a2i;
out[oidx1] = a1r - a2r;
out[oidx2] = a1r + a2r;
}
}
}
}
}
ar1 = 1;
ai1 = 0;
int idx01 = (ip - 1) * idl1;
for (int l = 1; l < ipph; l++) {
lc = ip - l;
ar1h = dcp * ar1 - dsp * ai1;
ai1 = dcp * ai1 + dsp * ar1;
ar1 = ar1h;
int idx1 = l * idl1;
int idx2 = lc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx3 = in_off + ik;
int idx4 = out_off + ik;
in[idx3 + idx1] = out[idx4] + ar1 * out[idx4 + idl1];
in[idx3 + idx2] = ai1 * out[idx4 + idx01];
}
dc2 = ar1;
ds2 = ai1;
ar2 = ar1;
ai2 = ai1;
for (int j = 2; j < ipph; j++) {
jc = ip - j;
ar2h = dc2 * ar2 - ds2 * ai2;
ai2 = dc2 * ai2 + ds2 * ar2;
ar2 = ar2h;
int idx5 = j * idl1;
int idx6 = jc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx7 = in_off + ik;
int idx8 = out_off + ik;
in[idx7 + idx1] += ar2 * out[idx8 + idx5];
in[idx7 + idx2] += ai2 * out[idx8 + idx6];
}
}
}
for (int j = 1; j < ipph; j++) {
int idx1 = j * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx2 = out_off + ik;
out[idx2] += out[idx2 + idx1];
}
}
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int oidx1 = out_off + idx3;
int iidx1 = in_off + idx3 + idx1;
int iidx2 = in_off + idx3 + idx2;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1 + idx1] = i1r - i2r;
out[oidx1 + idx2] = i1r + i2r;
}
}
if (ido == 1)
return;
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
for (int i = 2; i < ido; i += 2) {
int idx4 = out_off + i;
int idx5 = in_off + i;
int oidx1 = idx4 + idx3 + idx1;
int oidx2 = idx4 + idx3 + idx2;
int iidx1 = idx5 + idx3 + idx1;
int iidx2 = idx5 + idx3 + idx2;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
out[oidx1 - 1] = i1i - i2r;
out[oidx2 - 1] = i1i + i2r;
out[oidx1] = i1r + i2i;
out[oidx2] = i1r - i2i;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int i = 2; i < ido; i += 2) {
int idx4 = out_off + i;
int idx5 = in_off + i;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int oidx1 = idx4 + idx3 + idx1;
int oidx2 = idx4 + idx3 + idx2;
int iidx1 = idx5 + idx3 + idx1;
int iidx2 = idx5 + idx3 + idx2;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
out[oidx1 - 1] = i1i - i2r;
out[oidx2 - 1] = i1i + i2r;
out[oidx1] = i1r + i2i;
out[oidx2] = i1r - i2i;
}
}
}
}
System.arraycopy(out, out_off, in, in_off, idl1);
for (int j = 1; j < ip; j++) {
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx2 = k * ido + idx1;
in[in_off + idx2] = out[out_off + idx2];
}
}
if (nbd <= l1) {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
idij = is - 1;
int idx1 = j * l1 * ido;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
int idx4 = in_off + i;
int idx5 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int iidx1 = idx4 + idx3;
int oidx1 = idx5 + idx3;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
in[iidx1 - 1] = w1r * o1i - w1i * o1r;
in[iidx1] = w1r * o1r + w1i * o1i;
}
}
}
} else {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
idij = is - 1;
int idx3 = k * ido + idx1;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
int idx4 = in_off + i;
int idx5 = out_off + i;
int iidx1 = idx4 + idx3;
int oidx1 = idx5 + idx3;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
in[iidx1 - 1] = w1r * o1i - w1i * o1r;
in[iidx1] = w1r * o1r + w1i * o1i;
}
}
}
}
}
/*---------------------------------------------------------
cfftf1: further processing of Complex forward FFT
--------------------------------------------------------
void cfftf(float[] a, int offa, int isign) {
int idot;
int l1, l2;
int na, nf, ip, iw, ido, idl1;
int[] nac = new int[1];
final int twon = 2 * n;
int iw1, iw2;
float[] ch = new float[twon];
iw1 = twon;
iw2 = 4 * n;
nac[0] = 0;
nf = (int) wtable[1 + iw2];
na = 0;
l1 = 1;
iw = iw1;
for (int k1 = 2; k1 <= nf + 1; k1++) {
ip = (int) wtable[k1 + iw2];
l2 = ip * l1;
ido = n / l2;
idot = ido + ido;
idl1 = idot * l1;
switch (ip) {
case 4:
if (na == 0) {
passf4(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf4(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
case 2:
if (na == 0) {
passf2(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf2(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
passf3(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf3(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
passf5(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf5(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
default:
if (na == 0) {
passfg(nac, idot, ip, l1, idl1, a, offa, ch, 0, iw, isign);
} else {
passfg(nac, idot, ip, l1, idl1, ch, 0, a, offa, iw, isign);
}
if (nac[0] != 0)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * idot;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, twon);
}
/*----------------------------------------------------------------------
passf2: Complex FFT's forward/backward processing of factor 2;
isign is +1 for backward and -1 for forward transforms
----------------------------------------------------------------------
void passf2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset, final int isign) {
float t1i, t1r;
int iw1;
iw1 = offset;
int idx = ido * l1;
if (ido <= 2) {
for (int k = 0; k < l1; k++) {
int idx0 = k * ido;
int iidx1 = in_off + 2 * idx0;
int iidx2 = iidx1 + ido;
float a1r = in[iidx1];
float a1i = in[iidx1 + 1];
float a2r = in[iidx2];
float a2i = in[iidx2 + 1];
int oidx1 = out_off + idx0;
int oidx2 = oidx1 + idx;
out[oidx1] = a1r + a2r;
out[oidx1 + 1] = a1i + a2i;
out[oidx2] = a1r - a2r;
out[oidx2 + 1] = a1i - a2i;
}
} else {
for (int k = 0; k < l1; k++) {
for (int i = 0; i < ido - 1; i += 2) {
int idx0 = k * ido;
int iidx1 = in_off + i + 2 * idx0;
int iidx2 = iidx1 + ido;
float i1r = in[iidx1];
float i1i = in[iidx1 + 1];
float i2r = in[iidx2];
float i2i = in[iidx2 + 1];
int widx1 = i + iw1;
float w1r = wtable[widx1];
float w1i = isign * wtable[widx1 + 1];
t1r = i1r - i2r;
t1i = i1i - i2i;
int oidx1 = out_off + i + idx0;
int oidx2 = oidx1 + idx;
out[oidx1] = i1r + i2r;
out[oidx1 + 1] = i1i + i2i;
out[oidx2] = w1r * t1r - w1i * t1i;
out[oidx2 + 1] = w1r * t1i + w1i * t1r;
}
}
}
}
/*----------------------------------------------------------------------
passf3: Complex FFT's forward/backward processing of factor 3;
isign is +1 for backward and -1 for forward transforms
----------------------------------------------------------------------
void passf3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset, final int isign) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
float ci2, ci3, di2, di3, cr2, cr3, dr2, dr3, ti2, tr2;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
final int idxt = l1 * ido;
if (ido == 2) {
for (int k = 1; k <= l1; k++) {
int iidx1 = in_off + (3 * k - 2) * ido;
int iidx2 = iidx1 + ido;
int iidx3 = iidx1 - ido;
float i1r = in[iidx1];
float i1i = in[iidx1 + 1];
float i2r = in[iidx2];
float i2i = in[iidx2 + 1];
float i3r = in[iidx3];
float i3i = in[iidx3 + 1];
tr2 = i1r + i2r;
cr2 = i3r + taur * tr2;
ti2 = i1i + i2i;
ci2 = i3i + taur * ti2;
cr3 = isign * taui * (i1r - i2r);
ci3 = isign * taui * (i1i - i2i);
int oidx1 = out_off + (k - 1) * ido;
int oidx2 = oidx1 + idxt;
int oidx3 = oidx2 + idxt;
out[oidx1] = in[iidx3] + tr2;
out[oidx1 + 1] = i3i + ti2;
out[oidx2] = cr2 - ci3;
out[oidx2 + 1] = ci2 + cr3;
out[oidx3] = cr2 + ci3;
out[oidx3 + 1] = ci2 - cr3;
}
} else {
for (int k = 1; k <= l1; k++) {
int idx1 = in_off + (3 * k - 2) * ido;
int idx2 = out_off + (k - 1) * ido;
for (int i = 0; i < ido - 1; i += 2) {
int iidx1 = i + idx1;
int iidx2 = iidx1 + ido;
int iidx3 = iidx1 - ido;
float a1r = in[iidx1];
float a1i = in[iidx1 + 1];
float a2r = in[iidx2];
float a2i = in[iidx2 + 1];
float a3r = in[iidx3];
float a3i = in[iidx3 + 1];
tr2 = a1r + a2r;
cr2 = a3r + taur * tr2;
ti2 = a1i + a2i;
ci2 = a3i + taur * ti2;
cr3 = isign * taui * (a1r - a2r);
ci3 = isign * taui * (a1i - a2i);
dr2 = cr2 - ci3;
dr3 = cr2 + ci3;
di2 = ci2 + cr3;
di3 = ci2 - cr3;
int widx1 = i + iw1;
int widx2 = i + iw2;
float w1r = wtable[widx1];
float w1i = isign * wtable[widx1 + 1];
float w2r = wtable[widx2];
float w2i = isign * wtable[widx2 + 1];
int oidx1 = i + idx2;
int oidx2 = oidx1 + idxt;
int oidx3 = oidx2 + idxt;
out[oidx1] = a3r + tr2;
out[oidx1 + 1] = a3i + ti2;
out[oidx2] = w1r * dr2 - w1i * di2;
out[oidx2 + 1] = w1r * di2 + w1i * dr2;
out[oidx3] = w2r * dr3 - w2i * di3;
out[oidx3 + 1] = w2r * di3 + w2i * dr3;
}
}
}
}
/*----------------------------------------------------------------------
passf4: Complex FFT's forward/backward processing of factor 4;
isign is +1 for backward and -1 for forward transforms
---------------------------------------------------------------------- | FloatFFT::passf4 | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
void passf5(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset, final int isign)
/* isign==-1 for forward transform and+1 for backward transform */
{
final float tr11 = 0.309016994374947451262869435595348477f;
final float ti11 = 0.951056516295153531181938433292089030f;
final float tr12 = -0.809016994374947340240566973079694435f;
final float ti12 = 0.587785252292473248125759255344746634f;
float ci2, ci3, ci4, ci5, di3, di4, di5, di2, cr2, cr3, cr5, cr4, ti2, ti3, ti4, ti5, dr3, dr4, dr5, dr2, tr2, tr3, tr4, tr5;
int iw1, iw2, iw3, iw4;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
iw4 = iw3 + ido;
int idx0 = l1 * ido;
if (ido == 2) {
for (int k = 1; k <= l1; ++k) {
int iidx1 = in_off + (5 * k - 4) * ido + 1;
int iidx2 = iidx1 + ido;
int iidx3 = iidx1 - ido;
int iidx4 = iidx2 + ido;
int iidx5 = iidx4 + ido;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
ti5 = i1r - i5r;
ti2 = i1r + i5r;
ti4 = i2r - i4r;
ti3 = i2r + i4r;
tr5 = i1i - i5i;
tr2 = i1i + i5i;
tr4 = i2i - i4i;
tr3 = i2i + i4i;
cr2 = i3i + tr11 * tr2 + tr12 * tr3;
ci2 = i3r + tr11 * ti2 + tr12 * ti3;
cr3 = i3i + tr12 * tr2 + tr11 * tr3;
ci3 = i3r + tr12 * ti2 + tr11 * ti3;
cr5 = isign * (ti11 * tr5 + ti12 * tr4);
ci5 = isign * (ti11 * ti5 + ti12 * ti4);
cr4 = isign * (ti12 * tr5 - ti11 * tr4);
ci4 = isign * (ti12 * ti5 - ti11 * ti4);
int oidx1 = out_off + (k - 1) * ido;
int oidx2 = oidx1 + idx0;
int oidx3 = oidx2 + idx0;
int oidx4 = oidx3 + idx0;
int oidx5 = oidx4 + idx0;
out[oidx1] = i3i + tr2 + tr3;
out[oidx1 + 1] = i3r + ti2 + ti3;
out[oidx2] = cr2 - ci5;
out[oidx2 + 1] = ci2 + cr5;
out[oidx3] = cr3 - ci4;
out[oidx3 + 1] = ci3 + cr4;
out[oidx4] = cr3 + ci4;
out[oidx4 + 1] = ci3 - cr4;
out[oidx5] = cr2 + ci5;
out[oidx5 + 1] = ci2 - cr5;
}
} else {
for (int k = 1; k <= l1; k++) {
int idx1 = in_off + 1 + (k * 5 - 4) * ido;
int idx2 = out_off + (k - 1) * ido;
for (int i = 0; i < ido - 1; i += 2) {
int iidx1 = i + idx1;
int iidx2 = iidx1 + ido;
int iidx3 = iidx1 - ido;
int iidx4 = iidx2 + ido;
int iidx5 = iidx4 + ido;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
ti5 = i1r - i5r;
ti2 = i1r + i5r;
ti4 = i2r - i4r;
ti3 = i2r + i4r;
tr5 = i1i - i5i;
tr2 = i1i + i5i;
tr4 = i2i - i4i;
tr3 = i2i + i4i;
cr2 = i3i + tr11 * tr2 + tr12 * tr3;
ci2 = i3r + tr11 * ti2 + tr12 * ti3;
cr3 = i3i + tr12 * tr2 + tr11 * tr3;
ci3 = i3r + tr12 * ti2 + tr11 * ti3;
cr5 = isign * (ti11 * tr5 + ti12 * tr4);
ci5 = isign * (ti11 * ti5 + ti12 * ti4);
cr4 = isign * (ti12 * tr5 - ti11 * tr4);
ci4 = isign * (ti12 * ti5 - ti11 * ti4);
dr3 = cr3 - ci4;
dr4 = cr3 + ci4;
di3 = ci3 + cr4;
di4 = ci3 - cr4;
dr5 = cr2 + ci5;
dr2 = cr2 - ci5;
di5 = ci2 - cr5;
di2 = ci2 + cr5;
int widx1 = i + iw1;
int widx2 = i + iw2;
int widx3 = i + iw3;
int widx4 = i + iw4;
float w1r = wtable[widx1];
float w1i = isign * wtable[widx1 + 1];
float w2r = wtable[widx2];
float w2i = isign * wtable[widx2 + 1];
float w3r = wtable[widx3];
float w3i = isign * wtable[widx3 + 1];
float w4r = wtable[widx4];
float w4i = isign * wtable[widx4 + 1];
int oidx1 = i + idx2;
int oidx2 = oidx1 + idx0;
int oidx3 = oidx2 + idx0;
int oidx4 = oidx3 + idx0;
int oidx5 = oidx4 + idx0;
out[oidx1] = i3i + tr2 + tr3;
out[oidx1 + 1] = i3r + ti2 + ti3;
out[oidx2] = w1r * dr2 - w1i * di2;
out[oidx2 + 1] = w1r * di2 + w1i * dr2;
out[oidx3] = w2r * dr3 - w2i * di3;
out[oidx3 + 1] = w2r * di3 + w2i * dr3;
out[oidx4] = w3r * dr4 - w3i * di4;
out[oidx4 + 1] = w3r * di4 + w3i * dr4;
out[oidx5] = w4r * dr5 - w4i * di5;
out[oidx5 + 1] = w4r * di5 + w4i * dr5;
}
}
}
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. This method computes the full real inverse transform, i.e. you will get
the same result as from <code>complexInverse</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
public void realInverseFull(final float[] a, final int offa, boolean scale) {
final int twon = 2 * n;
switch (plan) {
case SPLIT_RADIX:
realInverse2(a, offa, scale);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n / 2 > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
Future<?>[] futures = new Future[nthreads];
int k = n / 2 / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n / 2 : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
int idx1, idx2;
for (int k = firstIdx; k < lastIdx; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
int idx1, idx2;
for (int k = 0; k < n / 2; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
a[offa + n] = -a[offa + 1];
a[offa + 1] = 0;
break;
case MIXED_RADIX:
rfftf(a, offa);
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
} else {
m = (n + 1) / 2;
}
for (int k = 1; k < m; k++) {
int idx1 = offa + 2 * k;
int idx2 = offa + twon - 2 * k;
a[idx1] = -a[idx1];
a[idx2 + 1] = -a[idx1];
a[idx2] = a[idx1 - 1];
}
for (int k = 1; k < n; k++) {
int idx = offa + n - k;
float tmp = a[idx + 1];
a[idx + 1] = a[idx];
a[idx] = tmp;
}
a[offa + 1] = 0;
break;
case BLUESTEIN:
bluestein_real_full(a, offa, 1);
if (scale) {
scale(n, a, offa, true);
}
break;
}
}
private void realInverse2(float[] a, int offa, boolean scale) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
float xi;
if (n > 4) {
cftfsub(n, a, offa, ip, nw, w);
rftbsub(n, a, offa, nc, w, nw);
} else if (n == 4) {
cftbsub(n, a, offa, ip, nw, w);
}
xi = a[offa] - a[offa + 1];
a[offa] += a[offa + 1];
a[offa + 1] = xi;
if (scale) {
scale(n, a, offa, false);
}
break;
case MIXED_RADIX:
rfftf(a, offa);
for (int k = n - 1; k >= 2; k--) {
int idx = offa + k;
float tmp = a[idx];
a[idx] = a[idx - 1];
a[idx - 1] = tmp;
}
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
for (int i = 1; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
} else {
m = (n - 1) / 2;
for (int i = 0; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
}
break;
case BLUESTEIN:
bluestein_real_inverse2(a, offa);
if (scale) {
scale(n, a, offa, false);
}
break;
}
}
private static int getReminder(int n, int[] factors) {
int reminder = n;
if (n <= 0) {
throw new IllegalArgumentException("n must be positive integer");
}
for (int i = 0; i < factors.length && reminder != 1; i++) {
int factor = factors[i];
while ((reminder % factor) == 0) {
reminder /= factor;
}
}
return reminder;
}
/* -------- initializing routines --------
/*---------------------------------------------------------
cffti: initialization of Complex FFT
--------------------------------------------------------
void cffti(int n, int offw) {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[offw + nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[offw + idx + 1] = wtable[offw + idx];
}
wtable[offw + 2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[offw + fourn] = n;
wtable[offw + 1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[offw + k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[offw + i - 1 + twon] = 1;
wtable[offw + i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[offw + idx - 1] = (float)Math.cos(arg);
wtable[offw + idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[offw + idx1 - 1] = wtable[offw + idx2 - 1];
wtable[offw + idx1] = wtable[offw + idx2];
}
}
l1 = l2;
}
}
void cffti() {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[idx + 1] = wtable[idx];
}
wtable[2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[fourn] = n;
wtable[1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[i - 1 + twon] = 1;
wtable[i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[idx - 1] = (float)Math.cos(arg);
wtable[idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[idx1 - 1] = wtable[idx2 - 1];
wtable[idx1] = wtable[idx2];
}
}
l1 = l2;
}
}
void rffti() {
if (n == 1)
return;
final int twon = 2 * n;
float argh;
int ntry = 0, i, j;
float argld;
int k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, is, nq, nr;
float arg;
int ido, ipm;
int nfm1;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
++j;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
++nf;
wtable_r[nf + 1 + twon] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + twon;
wtable_r[idx + 1] = wtable_r[idx];
}
wtable_r[2 + twon] = 2;
}
} while (nl != 1);
break;
}
wtable_r[twon] = n;
wtable_r[1 + twon] = nf;
argh = TWO_PI / (float) (n);
is = 0;
nfm1 = nf - 1;
l1 = 1;
if (nfm1 == 0)
return;
for (k1 = 1; k1 <= nfm1; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
ipm = ip - 1;
for (j = 1; j <= ipm; ++j) {
ld += l1;
i = is;
argld = (float) ld * argh;
fi = 0;
for (ii = 3; ii <= ido; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + n;
wtable_r[idx - 2] = (float)Math.cos(arg);
wtable_r[idx - 1] = (float)Math.sin(arg);
}
is += ido;
}
l1 = l2;
}
}
private void bluesteini() {
int k = 0;
float arg;
float pi_n = PI / n;
bk1[0] = 1;
bk1[1] = 0;
for (int i = 1; i < n; i++) {
k += 2 * i - 1;
if (k >= 2 * n)
k -= 2 * n;
arg = pi_n * k;
bk1[2 * i] = (float)Math.cos(arg);
bk1[2 * i + 1] = (float)Math.sin(arg);
}
float scale = (float)(1.0 / nBluestein);
bk2[0] = bk1[0] * scale;
bk2[1] = bk1[1] * scale;
for (int i = 2; i < 2 * n; i += 2) {
bk2[i] = bk1[i] * scale;
bk2[i + 1] = bk1[i + 1] * scale;
bk2[2 * nBluestein - i] = bk2[i];
bk2[2 * nBluestein - i + 1] = bk2[i + 1];
}
cftbsub(2 * nBluestein, bk2, 0, ip, nw, w);
}
private void makewt(int nw) {
int j, nwh, nw0, nw1;
float delta, wn4r, wk1r, wk1i, wk3r, wk3i;
float delta2, deltaj, deltaj3;
ip[0] = nw;
ip[1] = 1;
if (nw > 2) {
nwh = nw >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nwh);
delta2 = delta * 2;
wn4r = (float)Math.cos(delta * nwh);
w[0] = 1;
w[1] = wn4r;
if (nwh == 4) {
w[2] = (float)Math.cos(delta2);
w[3] = (float)Math.sin(delta2);
} else if (nwh > 4) {
makeipt(nw);
w[2] = (float)(0.5 / Math.cos(delta2));
w[3] = (float)(0.5 / Math.cos(delta * 6));
for (j = 4; j < nwh; j += 4) {
deltaj = delta * j;
deltaj3 = 3 * deltaj;
w[j] = (float)Math.cos(deltaj);
w[j + 1] = (float)Math.sin(deltaj);
w[j + 2] = (float)Math.cos(deltaj3);
w[j + 3] = (float)-Math.sin(deltaj3);
}
}
nw0 = 0;
while (nwh > 2) {
nw1 = nw0 + nwh;
nwh >>= 1;
w[nw1] = 1;
w[nw1 + 1] = wn4r;
if (nwh == 4) {
wk1r = w[nw0 + 4];
wk1i = w[nw0 + 5];
w[nw1 + 2] = wk1r;
w[nw1 + 3] = wk1i;
} else if (nwh > 4) {
wk1r = w[nw0 + 4];
wk3r = w[nw0 + 6];
w[nw1 + 2] = (float)(0.5 / wk1r);
w[nw1 + 3] = (float)(0.5 / wk3r);
for (j = 4; j < nwh; j += 4) {
int idx1 = nw0 + 2 * j;
int idx2 = nw1 + j;
wk1r = w[idx1];
wk1i = w[idx1 + 1];
wk3r = w[idx1 + 2];
wk3i = w[idx1 + 3];
w[idx2] = wk1r;
w[idx2 + 1] = wk1i;
w[idx2 + 2] = wk3r;
w[idx2 + 3] = wk3i;
}
}
nw0 = nw1;
}
}
}
private void makeipt(int nw) {
int j, l, m, m2, p, q;
ip[2] = 0;
ip[3] = 16;
m = 2;
for (l = nw; l > 32; l >>= 2) {
m2 = m << 1;
q = m2 << 3;
for (j = m; j < m2; j++) {
p = ip[j] << 2;
ip[m + j] = p;
ip[m2 + j] = p + q;
}
m = m2;
}
}
private void makect(int nc, float[] c, int startc) {
int j, nch;
float delta, deltaj;
ip[1] = nc;
if (nc > 1) {
nch = nc >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nch);
c[startc] = (float)Math.cos(delta * nch);
c[startc + nch] = (float)(0.5 * c[startc]);
for (j = 1; j < nch; j++) {
deltaj = delta * j;
c[startc + j] = (float)(0.5 * Math.cos(deltaj));
c[startc + nc - j] = (float)(0.5 * Math.sin(deltaj));
}
}
}
private void bluestein_complex(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_full(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_forward(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] + bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = -bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] + bk1[n] * ak[n];
}
}
private void bluestein_real_inverse(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
if (n % 2 == 0) {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n] = a[offa + 1] * bk1[n];
ak[n + 1] = a[offa + 1] * bk1[n + 1];
for (int i = n / 2 + 1; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
} else {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n - 1] = a[offa + n - 1] * bk1[n - 1] - a[offa + 1] * bk1[n];
ak[n] = a[offa + n - 1] * bk1[n] + a[offa + 1] * bk1[n - 1];
ak[n + 1] = a[offa + n - 1] * bk1[n + 1] + a[offa + 1] * bk1[n + 2];
ak[n + 2] = a[offa + n - 1] * bk1[n + 2] - a[offa + 1] * bk1[n + 1];
for (int i = (n - 1) / 2 + 2; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
}
private void bluestein_real_inverse2(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] - bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] - bk1[n] * ak[n];
}
}
/*---------------------------------------------------------
rfftf1: further processing of Real forward FFT
--------------------------------------------------------
void rfftf(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, kh, nf, ip, iw, ido, idl1;
final float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 1;
l2 = n;
iw = twon - 1;
for (int k1 = 1; k1 <= nf; ++k1) {
kh = nf - k1;
ip = (int) wtable_r[kh + 2 + twon];
l1 = l2 / ip;
ido = n / l2;
idl1 = ido * l1;
iw -= (ip - 1) * ido;
na = 1 - na;
switch (ip) {
case 2:
if (na == 0) {
radf2(ido, l1, a, offa, ch, 0, iw);
} else {
radf2(ido, l1, ch, 0, a, offa, iw);
}
break;
case 3:
if (na == 0) {
radf3(ido, l1, a, offa, ch, 0, iw);
} else {
radf3(ido, l1, ch, 0, a, offa, iw);
}
break;
case 4:
if (na == 0) {
radf4(ido, l1, a, offa, ch, 0, iw);
} else {
radf4(ido, l1, ch, 0, a, offa, iw);
}
break;
case 5:
if (na == 0) {
radf5(ido, l1, a, offa, ch, 0, iw);
} else {
radf5(ido, l1, ch, 0, a, offa, iw);
}
break;
default:
if (ido == 1)
na = 1 - na;
if (na == 0) {
radfg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
na = 1;
} else {
radfg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
na = 0;
}
break;
}
l2 = l1;
}
if (na == 1)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*---------------------------------------------------------
rfftb1: further processing of Real backward FFT
--------------------------------------------------------
void rfftb(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, nf, ip, iw, ido, idl1;
float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 0;
l1 = 1;
iw = n;
for (int k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
l2 = ip * l1;
ido = n / l2;
idl1 = ido * l1;
switch (ip) {
case 2:
if (na == 0) {
radb2(ido, l1, a, offa, ch, 0, iw);
} else {
radb2(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
radb3(ido, l1, a, offa, ch, 0, iw);
} else {
radb3(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 4:
if (na == 0) {
radb4(ido, l1, a, offa, ch, 0, iw);
} else {
radb4(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
radb5(ido, l1, a, offa, ch, 0, iw);
} else {
radb5(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
default:
if (na == 0) {
radbg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
} else {
radbg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
}
if (ido == 1)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * ido;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*-------------------------------------------------
radf2: Real FFT's forward processing of factor 2
-------------------------------------------------
void radf2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic, idx0, idx1, idx2, idx3, idx4;
float t1i, t1r, w1r, w1i;
int iw1;
iw1 = offset;
idx0 = l1 * ido;
idx1 = 2 * ido;
for (int k = 0; k < l1; k++) {
int oidx1 = out_off + k * idx1;
int oidx2 = oidx1 + idx1 - 1;
int iidx1 = in_off + k * ido;
int iidx2 = iidx1 + idx0;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx2] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
idx2 = 2 * idx1;
idx3 = idx2 + ido;
idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int oidx1 = out_off + i + idx2;
int oidx2 = out_off + ic + idx3;
int iidx1 = in_off + i + idx1;
int iidx2 = in_off + i + idx4;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
t1r = w1r * a2i + w1i * a2r;
t1i = w1r * a2r - w1i * a2i;
out[oidx1] = a1r + t1i;
out[oidx1 - 1] = a1i + t1r;
out[oidx2] = t1i - a1r;
out[oidx2 - 1] = a1i - t1r;
}
}
if (ido % 2 == 1)
return;
}
idx2 = 2 * idx1;
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
int oidx1 = out_off + idx2 + ido;
int iidx1 = in_off + ido - 1 + idx1;
out[oidx1] = -in[iidx1 + idx0];
out[oidx1 - 1] = in[iidx1];
}
}
/*-------------------------------------------------
radb2: Real FFT's backward processing of factor 2
-------------------------------------------------
void radb2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic;
float t1i, t1r, w1r, w1i;
int iw1 = offset;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int oidx1 = out_off + idx1;
int iidx1 = in_off + idx2;
int iidx2 = in_off + ido - 1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx1 + idx0] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx5 = i - 1 + iw1;
int idx6 = out_off + i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
w1r = wtable_r[idx5 - 1];
w1i = wtable_r[idx5];
int iidx1 = idx7 + idx2;
int iidx2 = idx8 + idx3;
int oidx1 = idx6 + idx1;
int oidx2 = idx6 + idx4;
t1r = in[iidx1 - 1] - in[iidx2 - 1];
t1i = in[iidx1] + in[iidx2];
float i1i = in[iidx1];
float i1r = in[iidx1 - 1];
float i2i = in[iidx2];
float i2r = in[iidx2 - 1];
out[oidx1 - 1] = i1r + i2r;
out[oidx1] = i1i - i2i;
out[oidx2 - 1] = w1r * t1r - w1i * t1i;
out[oidx2] = w1r * t1i + w1i * t1r;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int oidx1 = out_off + ido - 1 + idx1;
int iidx1 = in_off + idx2 + ido;
out[oidx1] = 2 * in[iidx1 - 1];
out[oidx1 + idx0] = -2 * in[iidx1];
}
}
/*-------------------------------------------------
radf3: Real FFT's forward processing of factor 3
-------------------------------------------------
void radf3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, di2, di3, cr2, dr2, dr3, ti2, ti3, tr2, tr3, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx3 = 2 * idx0;
int idx4 = (3 * k + 1) * ido;
int iidx1 = in_off + idx1;
int iidx2 = iidx1 + idx0;
int iidx3 = iidx1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
float i3r = in[iidx3];
cr2 = i2r + i3r;
out[out_off + 3 * idx1] = i1r + cr2;
out[out_off + idx4 + ido] = taui * (i3r - i2r);
out[out_off + ido - 1 + idx4] = i1r + taur * cr2;
}
if (ido == 1)
return;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int idx4 = 3 * idx3;
int idx5 = idx3 + idx0;
int idx6 = idx5 + idx0;
int idx7 = idx4 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx3;
int iidx2 = idx9 + idx5;
int iidx3 = idx9 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
cr2 = dr2 + dr3;
ci2 = di2 + di3;
tr2 = i1i + taur * cr2;
ti2 = i1r + taur * ci2;
tr3 = taui * (di2 - di3);
ti3 = taui * (dr3 - dr2);
int oidx1 = idx10 + idx4;
int oidx2 = idx11 + idx7;
int oidx3 = idx10 + idx8;
out[oidx1 - 1] = i1i + cr2;
out[oidx1] = i1r + ci2;
out[oidx2 - 1] = tr2 - tr3;
out[oidx2] = ti3 - ti2;
out[oidx3 - 1] = tr2 + tr3;
out[oidx3] = ti2 + ti3;
}
}
}
/*-------------------------------------------------
radb3: Real FFT's backward processing of factor 3
-------------------------------------------------
void radb3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, ci3, di2, di3, cr2, cr3, dr2, dr3, ti2, tr2, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int iidx1 = in_off + 3 * idx1;
int iidx2 = iidx1 + 2 * ido;
float i1i = in[iidx1];
tr2 = 2 * in[iidx2 - 1];
cr2 = i1i + taur * tr2;
ci3 = 2 * taui * in[iidx2];
out[out_off + idx1] = i1i + tr2;
out[out_off + (k + l1) * ido] = cr2 - ci3;
out[out_off + (k + 2 * l1) * ido] = cr2 + ci3;
}
if (ido == 1)
return;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 3 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx1 + idx0;
int idx6 = idx5 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
int idx9 = out_off + i;
int iidx1 = idx7 + idx2;
int iidx2 = idx7 + idx4;
int iidx3 = idx8 + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
tr2 = i2i + i3i;
cr2 = i1i + taur * tr2;
ti2 = i2r - i3r;
ci2 = i1r + taur * ti2;
cr3 = taui * (i2i - i3i);
ci3 = taui * (i2r + i3r);
dr2 = cr2 - ci3;
dr3 = cr2 + ci3;
di2 = ci2 + cr3;
di3 = ci2 - cr3;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int oidx1 = idx9 + idx1;
int oidx2 = idx9 + idx5;
int oidx3 = idx9 + idx6;
out[oidx1 - 1] = i1i + tr2;
out[oidx1] = i1r + ti2;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
}
}
}
/*-------------------------------------------------
radf4: Real FFT's forward processing of factor 4
-------------------------------------------------
void radf4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float hsqt2 = 0.707106781186547572737310929369414225f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = offset + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx3];
float i3r = in[in_off + idx4];
float i4r = in[in_off + idx5];
tr1 = i2r + i4r;
tr2 = i1r + i3r;
int oidx1 = out_off + idx2;
int oidx2 = out_off + idx6 + ido;
out[oidx1] = tr1 + tr2;
out[oidx2 - 1 + ido + ido] = tr2 - tr1;
out[oidx2 - 1] = i1r - i3r;
out[oidx2] = i4r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx1;
int iidx2 = idx9 + idx2;
int iidx3 = idx9 + idx3;
int iidx4 = idx9 + idx4;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
cr2 = w1r * i2i + w1i * i2r;
ci2 = w1r * i2r - w1i * i2i;
cr3 = w2r * i3i + w2i * i3r;
ci3 = w2r * i3r - w2i * i3i;
cr4 = w3r * i4i + w3i * i4r;
ci4 = w3r * i4r - w3i * i4i;
tr1 = cr2 + cr4;
tr4 = cr4 - cr2;
ti1 = ci2 + ci4;
ti4 = ci2 - ci4;
ti2 = i1r + ci3;
ti3 = i1r - ci3;
tr2 = i1i + cr3;
tr3 = i1i - cr3;
int oidx1 = idx10 + idx5;
int oidx2 = idx11 + idx6;
int oidx3 = idx10 + idx7;
int oidx4 = idx11 + idx8;
out[oidx1 - 1] = tr1 + tr2;
out[oidx4 - 1] = tr2 - tr1;
out[oidx1] = ti1 + ti2;
out[oidx4] = ti1 - ti2;
out[oidx3 - 1] = ti4 + tr3;
out[oidx2 - 1] = tr3 - ti4;
out[oidx3] = tr4 + ti3;
out[oidx2] = tr4 - ti3;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1i = in[idx9 - 1 + idx1];
float i2i = in[idx9 - 1 + idx3];
float i3i = in[idx9 - 1 + idx4];
float i4i = in[idx9 - 1 + idx5];
ti1 = -hsqt2 * (i2i + i4i);
tr1 = hsqt2 * (i2i - i4i);
out[idx10 - 1 + idx2] = tr1 + i1i;
out[idx10 - 1 + idx7] = i1i - tr1;
out[out_off + idx6] = ti1 - i3i;
out[out_off + idx8] = ti1 + i3i;
}
}
/*-------------------------------------------------
radb4: Real FFT's backward processing of factor 4
-------------------------------------------------
void radb4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float sqrt2 = 1.41421356237309514547462185873882845f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4;
float ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
float i1r = in[in_off + idx2];
float i2r = in[in_off + idx7];
float i3r = in[in_off + ido - 1 + idx8];
float i4r = in[in_off + ido - 1 + idx6];
tr1 = i1r - i3r;
tr2 = i1r + i3r;
tr3 = i4r + i4r;
tr4 = i2r + i2r;
out[out_off + idx1] = tr2 + tr3;
out[out_off + idx3] = tr1 - tr4;
out[out_off + idx4] = tr2 - tr3;
out[out_off + idx5] = tr1 + tr4;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx12 = in_off + i;
int idx13 = in_off + ic;
int idx14 = out_off + i;
int iidx1 = idx12 + idx5;
int iidx2 = idx13 + idx6;
int iidx3 = idx12 + idx7;
int iidx4 = idx13 + idx8;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
ti1 = i1r + i4r;
ti2 = i1r - i4r;
ti3 = i3r - i2r;
tr4 = i3r + i2r;
tr1 = i1i - i4i;
tr2 = i1i + i4i;
ti4 = i3i - i2i;
tr3 = i3i + i2i;
cr3 = tr2 - tr3;
ci3 = ti2 - ti3;
cr2 = tr1 - tr4;
cr4 = tr1 + tr4;
ci2 = ti1 + ti4;
ci4 = ti1 - ti4;
int oidx1 = idx14 + idx1;
int oidx2 = idx14 + idx2;
int oidx3 = idx14 + idx3;
int oidx4 = idx14 + idx4;
out[oidx1 - 1] = tr2 + tr3;
out[oidx1] = ti2 + ti3;
out[oidx2 - 1] = w1r * cr2 - w1i * ci2;
out[oidx2] = w1r * ci2 + w1i * cr2;
out[oidx3 - 1] = w2r * cr3 - w2i * ci3;
out[oidx3] = w2r * ci3 + w2i * cr3;
out[oidx4 - 1] = w3r * cr4 - w3i * ci4;
out[oidx4] = w3r * ci4 + w3i * cr4;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1r = in[idx9 - 1 + idx2];
float i2r = in[idx9 - 1 + idx7];
float i3r = in[in_off + idx6];
float i4r = in[in_off + idx8];
ti1 = i3r + i4r;
ti2 = i4r - i3r;
tr1 = i1r - i2r;
tr2 = i1r + i2r;
out[idx10 - 1 + idx1] = tr2 + tr2;
out[idx10 - 1 + idx3] = sqrt2 * (tr1 - ti1);
out[idx10 - 1 + idx4] = ti2 + ti2;
out[idx10 - 1 + idx5] = -sqrt2 * (tr1 + ti1);
}
}
/*-------------------------------------------------
radf5: Real FFT's forward processing of factor 5
-------------------------------------------------
void radf5(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float tr11 = 0.309016994374947451262869435595348477f;
final float ti11 = 0.951056516295153531181938433292089030f;
final float tr12 = -0.809016994374947340240566973079694435f;
final float ti12 = 0.587785252292473248125759255344746634f;
int i, ic;
float ci2, di2, ci4, ci5, di3, di4, di5, ci3, cr2, cr3, dr2, dr3, dr4, dr5, cr5, cr4, ti2, ti3, ti5, ti4, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
int iw1, iw2, iw3, iw4;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
iw4 = iw3 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
int idx11 = out_off + ido - 1;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx7];
float i3r = in[in_off + idx8];
float i4r = in[in_off + idx9];
float i5r = in[in_off + idx10];
cr2 = i5r + i2r;
ci5 = i5r - i2r;
cr3 = i4r + i3r;
ci4 = i4r - i3r;
out[out_off + idx2] = i1r + cr2 + cr3;
out[idx11 + idx3] = i1r + tr11 * cr2 + tr12 * cr3;
out[out_off + idx4] = ti11 * ci5 + ti12 * ci4;
out[idx11 + idx5] = i1r + tr12 * cr2 + tr11 * cr3;
out[out_off + idx6] = ti12 * ci5 - ti11 * ci4;
}
if (ido == 1)
return;
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
for (i = 2; i < ido; i += 2) {
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
int widx4 = i - 1 + iw4;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
w4r = wtable_r[widx4 - 1];
w4i = wtable_r[widx4];
ic = ido - i;
int idx15 = in_off + i;
int idx16 = out_off + i;
int idx17 = out_off + ic;
int iidx1 = idx15 + idx1;
int iidx2 = idx15 + idx7;
int iidx3 = idx15 + idx8;
int iidx4 = idx15 + idx9;
int iidx5 = idx15 + idx10;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
dr4 = w3r * i4i + w3i * i4r;
di4 = w3r * i4r - w3i * i4i;
dr5 = w4r * i5i + w4i * i5r;
di5 = w4r * i5r - w4i * i5i;
cr2 = dr2 + dr5;
ci5 = dr5 - dr2;
cr5 = di2 - di5;
ci2 = di2 + di5;
cr3 = dr3 + dr4;
ci4 = dr4 - dr3;
cr4 = di3 - di4;
ci3 = di3 + di4;
tr2 = i1i + tr11 * cr2 + tr12 * cr3;
ti2 = i1r + tr11 * ci2 + tr12 * ci3;
tr3 = i1i + tr12 * cr2 + tr11 * cr3;
ti3 = i1r + tr12 * ci2 + tr11 * ci3;
tr5 = ti11 * cr5 + ti12 * cr4;
ti5 = ti11 * ci5 + ti12 * ci4;
tr4 = ti12 * cr5 - ti11 * cr4;
ti4 = ti12 * ci5 - ti11 * ci4;
int oidx1 = idx16 + idx2;
int oidx2 = idx17 + idx3;
int oidx3 = idx16 + idx4;
int oidx4 = idx17 + idx5;
int oidx5 = idx16 + idx6;
out[oidx1 - 1] = i1i + cr2 + cr3;
out[oidx1] = i1r + ci2 + ci3;
out[oidx3 - 1] = tr2 + tr5;
out[oidx2 - 1] = tr2 - tr5;
out[oidx3] = ti2 + ti5;
out[oidx2] = ti5 - ti2;
out[oidx5 - 1] = tr3 + tr4;
out[oidx4 - 1] = tr3 - tr4;
out[oidx5] = ti3 + ti4;
out[oidx4] = ti4 - ti3;
}
}
}
/*-------------------------------------------------
radb5: Real FFT's backward processing of factor 5
-------------------------------------------------
void radb5(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float tr11 = 0.309016994374947451262869435595348477f;
final float ti11 = 0.951056516295153531181938433292089030f;
final float tr12 = -0.809016994374947340240566973079694435f;
final float ti12 = 0.587785252292473248125759255344746634f;
int i, ic;
float ci2, ci3, ci4, ci5, di3, di4, di5, di2, cr2, cr3, cr5, cr4, ti2, ti3, ti4, ti5, dr3, dr4, dr5, dr2, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
int iw1, iw2, iw3, iw4;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
iw4 = iw3 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
int idx11 = in_off + ido - 1;
float i1r = in[in_off + idx2];
ti5 = 2 * in[in_off + idx4];
ti4 = 2 * in[in_off + idx6];
tr2 = 2 * in[idx11 + idx3];
tr3 = 2 * in[idx11 + idx5];
cr2 = i1r + tr11 * tr2 + tr12 * tr3;
cr3 = i1r + tr12 * tr2 + tr11 * tr3;
ci5 = ti11 * ti5 + ti12 * ti4;
ci4 = ti12 * ti5 - ti11 * ti4;
out[out_off + idx1] = i1r + tr2 + tr3;
out[out_off + idx7] = cr2 - ci5;
out[out_off + idx8] = cr3 - ci4;
out[out_off + idx9] = cr3 + ci4;
out[out_off + idx10] = cr2 + ci5;
}
if (ido == 1)
return;
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
int widx4 = i - 1 + iw4;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
w4r = wtable_r[widx4 - 1];
w4i = wtable_r[widx4];
int idx15 = in_off + i;
int idx16 = in_off + ic;
int idx17 = out_off + i;
int iidx1 = idx15 + idx2;
int iidx2 = idx16 + idx3;
int iidx3 = idx15 + idx4;
int iidx4 = idx16 + idx5;
int iidx5 = idx15 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
ti5 = i3r + i2r;
ti2 = i3r - i2r;
ti4 = i5r + i4r;
ti3 = i5r - i4r;
tr5 = i3i - i2i;
tr2 = i3i + i2i;
tr4 = i5i - i4i;
tr3 = i5i + i4i;
cr2 = i1i + tr11 * tr2 + tr12 * tr3;
ci2 = i1r + tr11 * ti2 + tr12 * ti3;
cr3 = i1i + tr12 * tr2 + tr11 * tr3;
ci3 = i1r + tr12 * ti2 + tr11 * ti3;
cr5 = ti11 * tr5 + ti12 * tr4;
ci5 = ti11 * ti5 + ti12 * ti4;
cr4 = ti12 * tr5 - ti11 * tr4;
ci4 = ti12 * ti5 - ti11 * ti4;
dr3 = cr3 - ci4;
dr4 = cr3 + ci4;
di3 = ci3 + cr4;
di4 = ci3 - cr4;
dr5 = cr2 + ci5;
dr2 = cr2 - ci5;
di5 = ci2 - cr5;
di2 = ci2 + cr5;
int oidx1 = idx17 + idx1;
int oidx2 = idx17 + idx7;
int oidx3 = idx17 + idx8;
int oidx4 = idx17 + idx9;
int oidx5 = idx17 + idx10;
out[oidx1 - 1] = i1i + tr2 + tr3;
out[oidx1] = i1r + ti2 + ti3;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
out[oidx4 - 1] = w3r * dr4 - w3i * di4;
out[oidx4] = w3r * di4 + w3i * dr4;
out[oidx5 - 1] = w4r * dr5 - w4i * di5;
out[oidx5] = w4r * di5 + w4i * dr5;
}
}
}
/*---------------------------------------------------------
radfg: Real FFT's forward processing of general factor
--------------------------------------------------------
void radfg(final int ido, final int ip, final int l1, final int idl1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int idij, ipph, j2, ic, jc, lc, is, nbd;
float dc2, ai1, ai2, ar1, ar2, ds2, dcp, arg, dsp, ar1h, ar2h, w1r, w1i;
int iw1 = offset;
arg = TWO_PI / (float) ip;
dcp = (float)Math.cos(arg);
dsp = (float)Math.sin(arg);
ipph = (ip + 1) / 2;
nbd = (ido - 1) / 2;
if (ido != 1) {
if (idl1 >= 0) System.arraycopy(in, in_off, out, out_off, idl1);
for (int j = 1; j < ip; j++) {
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx2 = k * ido + idx1;
out[out_off + idx2] = in[in_off + idx2];
}
}
if (nbd <= l1) {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
idij = is - 1;
int idx1 = j * l1 * ido;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
int idx4 = in_off + i;
int idx5 = out_off + i;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int oidx1 = idx5 + idx3;
int iidx1 = idx4 + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
out[oidx1 - 1] = w1r * i1i + w1i * i1r;
out[oidx1] = w1r * i1r - w1i * i1i;
}
}
}
} else {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
idij = is - 1;
int idx3 = k * ido + idx1;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
int oidx1 = out_off + i + idx3;
int iidx1 = in_off + i + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
out[oidx1 - 1] = w1r * i1i + w1i * i1r;
out[oidx1] = w1r * i1r - w1i * i1i;
}
}
}
}
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
for (int i = 2; i < ido; i += 2) {
int idx5 = in_off + i;
int idx6 = out_off + i;
int iidx1 = idx5 + idx3;
int iidx2 = idx5 + idx4;
int oidx1 = idx6 + idx3;
int oidx2 = idx6 + idx4;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx1] = o1r + o2r;
in[iidx2 - 1] = o1r - o2r;
in[iidx2] = o2i - o1i;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int i = 2; i < ido; i += 2) {
int idx5 = in_off + i;
int idx6 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
int iidx1 = idx5 + idx3;
int iidx2 = idx5 + idx4;
int oidx1 = idx6 + idx3;
int oidx2 = idx6 + idx4;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx1] = o1r + o2r;
in[iidx2 - 1] = o1r - o2r;
in[iidx2] = o2i - o1i;
}
}
}
}
} else {
System.arraycopy(out, out_off, in, in_off, idl1);
}
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
int oidx1 = out_off + idx3;
int oidx2 = out_off + idx4;
float o1r = out[oidx1];
float o2r = out[oidx2];
in[in_off + idx3] = o1r + o2r;
in[in_off + idx4] = o2r - o1r;
}
}
ar1 = 1;
ai1 = 0;
int idx0 = (ip - 1) * idl1;
for (int l = 1; l < ipph; l++) {
lc = ip - l;
ar1h = dcp * ar1 - dsp * ai1;
ai1 = dcp * ai1 + dsp * ar1;
ar1 = ar1h;
int idx1 = l * idl1;
int idx2 = lc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx3 = out_off + ik;
int idx4 = in_off + ik;
out[idx3 + idx1] = in[idx4] + ar1 * in[idx4 + idl1];
out[idx3 + idx2] = ai1 * in[idx4 + idx0];
}
dc2 = ar1;
ds2 = ai1;
ar2 = ar1;
ai2 = ai1;
for (int j = 2; j < ipph; j++) {
jc = ip - j;
ar2h = dc2 * ar2 - ds2 * ai2;
ai2 = dc2 * ai2 + ds2 * ar2;
ar2 = ar2h;
int idx3 = j * idl1;
int idx4 = jc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx5 = out_off + ik;
int idx6 = in_off + ik;
out[idx5 + idx1] += ar2 * in[idx6 + idx3];
out[idx5 + idx2] += ai2 * in[idx6 + idx4];
}
}
}
for (int j = 1; j < ipph; j++) {
int idx1 = j * idl1;
for (int ik = 0; ik < idl1; ik++) {
out[out_off + ik] += in[in_off + ik + idx1];
}
}
if (ido >= l1) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = idx1 * ip;
for (int i = 0; i < ido; i++) {
in[in_off + i + idx2] = out[out_off + i + idx1];
}
}
} else {
for (int i = 0; i < ido; i++) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
in[in_off + i + idx1 * ip] = out[out_off + i + idx1];
}
}
}
int idx01 = ip * ido;
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido;
int idx5 = idx4 + idx1;
int idx6 = idx4 + idx2;
int idx7 = k * idx01;
in[in_off + ido - 1 + idx3 - ido + idx7] = out[out_off + idx5];
in[in_off + idx3 + idx7] = out[out_off + idx6];
}
}
if (ido == 1)
return;
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * idx01;
int idx5 = k * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx6 = in_off + i;
int idx7 = in_off + ic;
int idx8 = out_off + i;
int iidx1 = idx6 + idx3 + idx4;
int iidx2 = idx7 + idx3 - ido + idx4;
int oidx1 = idx8 + idx5 + idx1;
int oidx2 = idx8 + idx5 + idx2;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx2 - 1] = o1i - o2i;
in[iidx1] = o1r + o2r;
in[iidx2] = o2r - o1r;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx6 = in_off + i;
int idx7 = in_off + ic;
int idx8 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx4 = k * idx01;
int idx5 = k * ido;
int iidx1 = idx6 + idx3 + idx4;
int iidx2 = idx7 + idx3 - ido + idx4;
int oidx1 = idx8 + idx5 + idx1;
int oidx2 = idx8 + idx5 + idx2;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx2 - 1] = o1i - o2i;
in[iidx1] = o1r + o2r;
in[iidx2] = o2r - o1r;
}
}
}
}
}
/*---------------------------------------------------------
radbg: Real FFT's backward processing of general factor
--------------------------------------------------------
void radbg(final int ido, final int ip, final int l1, final int idl1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int idij, ipph, j2, ic, jc, lc, is;
float dc2, ai1, ai2, ar1, ar2, ds2, w1r, w1i;
int nbd;
float dcp, arg, dsp, ar1h, ar2h;
int iw1 = offset;
arg = TWO_PI / (float) ip;
dcp = (float)Math.cos(arg);
dsp = (float)Math.sin(arg);
nbd = (ido - 1) / 2;
ipph = (ip + 1) / 2;
int idx0 = ip * ido;
if (ido >= l1) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = k * idx0;
for (int i = 0; i < ido; i++) {
out[out_off + i + idx1] = in[in_off + i + idx2];
}
}
} else {
for (int i = 0; i < ido; i++) {
int idx1 = out_off + i;
int idx2 = in_off + i;
for (int k = 0; k < l1; k++) {
out[idx1 + k * ido] = in[idx2 + k * idx0];
}
}
}
int iidx0 = in_off + ido - 1;
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido;
int idx5 = idx4 * ip;
int iidx1 = iidx0 + idx3 + idx5 - ido;
int iidx2 = in_off + idx3 + idx5;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[out_off + idx4 + idx1] = i1r + i1r;
out[out_off + idx4 + idx2] = i2r + i2r;
}
}
if (ido != 1) {
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = 2 * j * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido + idx1;
int idx5 = k * ido + idx2;
int idx6 = k * ip * ido + idx3;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = out_off + i;
int idx8 = in_off + ic;
int idx9 = in_off + i;
int oidx1 = idx7 + idx4;
int oidx2 = idx7 + idx5;
int iidx1 = idx9 + idx6;
int iidx2 = idx8 + idx6 - ido;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
out[oidx1 - 1] = a1i + a2i;
out[oidx2 - 1] = a1i - a2i;
out[oidx1] = a1r - a2r;
out[oidx2] = a1r + a2r;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = 2 * j * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = out_off + i;
int idx8 = in_off + ic;
int idx9 = in_off + i;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido + idx1;
int idx5 = k * ido + idx2;
int idx6 = k * ip * ido + idx3;
int oidx1 = idx7 + idx4;
int oidx2 = idx7 + idx5;
int iidx1 = idx9 + idx6;
int iidx2 = idx8 + idx6 - ido;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
out[oidx1 - 1] = a1i + a2i;
out[oidx2 - 1] = a1i - a2i;
out[oidx1] = a1r - a2r;
out[oidx2] = a1r + a2r;
}
}
}
}
}
ar1 = 1;
ai1 = 0;
int idx01 = (ip - 1) * idl1;
for (int l = 1; l < ipph; l++) {
lc = ip - l;
ar1h = dcp * ar1 - dsp * ai1;
ai1 = dcp * ai1 + dsp * ar1;
ar1 = ar1h;
int idx1 = l * idl1;
int idx2 = lc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx3 = in_off + ik;
int idx4 = out_off + ik;
in[idx3 + idx1] = out[idx4] + ar1 * out[idx4 + idl1];
in[idx3 + idx2] = ai1 * out[idx4 + idx01];
}
dc2 = ar1;
ds2 = ai1;
ar2 = ar1;
ai2 = ai1;
for (int j = 2; j < ipph; j++) {
jc = ip - j;
ar2h = dc2 * ar2 - ds2 * ai2;
ai2 = dc2 * ai2 + ds2 * ar2;
ar2 = ar2h;
int idx5 = j * idl1;
int idx6 = jc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx7 = in_off + ik;
int idx8 = out_off + ik;
in[idx7 + idx1] += ar2 * out[idx8 + idx5];
in[idx7 + idx2] += ai2 * out[idx8 + idx6];
}
}
}
for (int j = 1; j < ipph; j++) {
int idx1 = j * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx2 = out_off + ik;
out[idx2] += out[idx2 + idx1];
}
}
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int oidx1 = out_off + idx3;
int iidx1 = in_off + idx3 + idx1;
int iidx2 = in_off + idx3 + idx2;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1 + idx1] = i1r - i2r;
out[oidx1 + idx2] = i1r + i2r;
}
}
if (ido == 1)
return;
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
for (int i = 2; i < ido; i += 2) {
int idx4 = out_off + i;
int idx5 = in_off + i;
int oidx1 = idx4 + idx3 + idx1;
int oidx2 = idx4 + idx3 + idx2;
int iidx1 = idx5 + idx3 + idx1;
int iidx2 = idx5 + idx3 + idx2;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
out[oidx1 - 1] = i1i - i2r;
out[oidx2 - 1] = i1i + i2r;
out[oidx1] = i1r + i2i;
out[oidx2] = i1r - i2i;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int i = 2; i < ido; i += 2) {
int idx4 = out_off + i;
int idx5 = in_off + i;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int oidx1 = idx4 + idx3 + idx1;
int oidx2 = idx4 + idx3 + idx2;
int iidx1 = idx5 + idx3 + idx1;
int iidx2 = idx5 + idx3 + idx2;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
out[oidx1 - 1] = i1i - i2r;
out[oidx2 - 1] = i1i + i2r;
out[oidx1] = i1r + i2i;
out[oidx2] = i1r - i2i;
}
}
}
}
System.arraycopy(out, out_off, in, in_off, idl1);
for (int j = 1; j < ip; j++) {
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx2 = k * ido + idx1;
in[in_off + idx2] = out[out_off + idx2];
}
}
if (nbd <= l1) {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
idij = is - 1;
int idx1 = j * l1 * ido;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
int idx4 = in_off + i;
int idx5 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int iidx1 = idx4 + idx3;
int oidx1 = idx5 + idx3;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
in[iidx1 - 1] = w1r * o1i - w1i * o1r;
in[iidx1] = w1r * o1r + w1i * o1i;
}
}
}
} else {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
idij = is - 1;
int idx3 = k * ido + idx1;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
int idx4 = in_off + i;
int idx5 = out_off + i;
int iidx1 = idx4 + idx3;
int oidx1 = idx5 + idx3;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
in[iidx1 - 1] = w1r * o1i - w1i * o1r;
in[iidx1] = w1r * o1r + w1i * o1i;
}
}
}
}
}
/*---------------------------------------------------------
cfftf1: further processing of Complex forward FFT
--------------------------------------------------------
void cfftf(float[] a, int offa, int isign) {
int idot;
int l1, l2;
int na, nf, ip, iw, ido, idl1;
int[] nac = new int[1];
final int twon = 2 * n;
int iw1, iw2;
float[] ch = new float[twon];
iw1 = twon;
iw2 = 4 * n;
nac[0] = 0;
nf = (int) wtable[1 + iw2];
na = 0;
l1 = 1;
iw = iw1;
for (int k1 = 2; k1 <= nf + 1; k1++) {
ip = (int) wtable[k1 + iw2];
l2 = ip * l1;
ido = n / l2;
idot = ido + ido;
idl1 = idot * l1;
switch (ip) {
case 4:
if (na == 0) {
passf4(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf4(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
case 2:
if (na == 0) {
passf2(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf2(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
passf3(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf3(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
passf5(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf5(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
default:
if (na == 0) {
passfg(nac, idot, ip, l1, idl1, a, offa, ch, 0, iw, isign);
} else {
passfg(nac, idot, ip, l1, idl1, ch, 0, a, offa, iw, isign);
}
if (nac[0] != 0)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * idot;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, twon);
}
/*----------------------------------------------------------------------
passf2: Complex FFT's forward/backward processing of factor 2;
isign is +1 for backward and -1 for forward transforms
----------------------------------------------------------------------
void passf2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset, final int isign) {
float t1i, t1r;
int iw1;
iw1 = offset;
int idx = ido * l1;
if (ido <= 2) {
for (int k = 0; k < l1; k++) {
int idx0 = k * ido;
int iidx1 = in_off + 2 * idx0;
int iidx2 = iidx1 + ido;
float a1r = in[iidx1];
float a1i = in[iidx1 + 1];
float a2r = in[iidx2];
float a2i = in[iidx2 + 1];
int oidx1 = out_off + idx0;
int oidx2 = oidx1 + idx;
out[oidx1] = a1r + a2r;
out[oidx1 + 1] = a1i + a2i;
out[oidx2] = a1r - a2r;
out[oidx2 + 1] = a1i - a2i;
}
} else {
for (int k = 0; k < l1; k++) {
for (int i = 0; i < ido - 1; i += 2) {
int idx0 = k * ido;
int iidx1 = in_off + i + 2 * idx0;
int iidx2 = iidx1 + ido;
float i1r = in[iidx1];
float i1i = in[iidx1 + 1];
float i2r = in[iidx2];
float i2i = in[iidx2 + 1];
int widx1 = i + iw1;
float w1r = wtable[widx1];
float w1i = isign * wtable[widx1 + 1];
t1r = i1r - i2r;
t1i = i1i - i2i;
int oidx1 = out_off + i + idx0;
int oidx2 = oidx1 + idx;
out[oidx1] = i1r + i2r;
out[oidx1 + 1] = i1i + i2i;
out[oidx2] = w1r * t1r - w1i * t1i;
out[oidx2 + 1] = w1r * t1i + w1i * t1r;
}
}
}
}
/*----------------------------------------------------------------------
passf3: Complex FFT's forward/backward processing of factor 3;
isign is +1 for backward and -1 for forward transforms
----------------------------------------------------------------------
void passf3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset, final int isign) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
float ci2, ci3, di2, di3, cr2, cr3, dr2, dr3, ti2, tr2;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
final int idxt = l1 * ido;
if (ido == 2) {
for (int k = 1; k <= l1; k++) {
int iidx1 = in_off + (3 * k - 2) * ido;
int iidx2 = iidx1 + ido;
int iidx3 = iidx1 - ido;
float i1r = in[iidx1];
float i1i = in[iidx1 + 1];
float i2r = in[iidx2];
float i2i = in[iidx2 + 1];
float i3r = in[iidx3];
float i3i = in[iidx3 + 1];
tr2 = i1r + i2r;
cr2 = i3r + taur * tr2;
ti2 = i1i + i2i;
ci2 = i3i + taur * ti2;
cr3 = isign * taui * (i1r - i2r);
ci3 = isign * taui * (i1i - i2i);
int oidx1 = out_off + (k - 1) * ido;
int oidx2 = oidx1 + idxt;
int oidx3 = oidx2 + idxt;
out[oidx1] = in[iidx3] + tr2;
out[oidx1 + 1] = i3i + ti2;
out[oidx2] = cr2 - ci3;
out[oidx2 + 1] = ci2 + cr3;
out[oidx3] = cr2 + ci3;
out[oidx3 + 1] = ci2 - cr3;
}
} else {
for (int k = 1; k <= l1; k++) {
int idx1 = in_off + (3 * k - 2) * ido;
int idx2 = out_off + (k - 1) * ido;
for (int i = 0; i < ido - 1; i += 2) {
int iidx1 = i + idx1;
int iidx2 = iidx1 + ido;
int iidx3 = iidx1 - ido;
float a1r = in[iidx1];
float a1i = in[iidx1 + 1];
float a2r = in[iidx2];
float a2i = in[iidx2 + 1];
float a3r = in[iidx3];
float a3i = in[iidx3 + 1];
tr2 = a1r + a2r;
cr2 = a3r + taur * tr2;
ti2 = a1i + a2i;
ci2 = a3i + taur * ti2;
cr3 = isign * taui * (a1r - a2r);
ci3 = isign * taui * (a1i - a2i);
dr2 = cr2 - ci3;
dr3 = cr2 + ci3;
di2 = ci2 + cr3;
di3 = ci2 - cr3;
int widx1 = i + iw1;
int widx2 = i + iw2;
float w1r = wtable[widx1];
float w1i = isign * wtable[widx1 + 1];
float w2r = wtable[widx2];
float w2i = isign * wtable[widx2 + 1];
int oidx1 = i + idx2;
int oidx2 = oidx1 + idxt;
int oidx3 = oidx2 + idxt;
out[oidx1] = a3r + tr2;
out[oidx1 + 1] = a3i + ti2;
out[oidx2] = w1r * dr2 - w1i * di2;
out[oidx2 + 1] = w1r * di2 + w1i * dr2;
out[oidx3] = w2r * dr3 - w2i * di3;
out[oidx3 + 1] = w2r * di3 + w2i * dr3;
}
}
}
}
/*----------------------------------------------------------------------
passf4: Complex FFT's forward/backward processing of factor 4;
isign is +1 for backward and -1 for forward transforms
----------------------------------------------------------------------
void passf4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset, final int isign) {
float ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
if (ido == 2) {
for (int k = 0; k < l1; k++) {
int idxt1 = k * ido;
int iidx1 = in_off + 4 * idxt1 + 1;
int iidx2 = iidx1 + ido;
int iidx3 = iidx2 + ido;
int iidx4 = iidx3 + ido;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
ti1 = i1r - i3r;
ti2 = i1r + i3r;
tr4 = i4r - i2r;
ti3 = i2r + i4r;
tr1 = i1i - i3i;
tr2 = i1i + i3i;
ti4 = i2i - i4i;
tr3 = i2i + i4i;
int oidx1 = out_off + idxt1;
int oidx2 = oidx1 + idx0;
int oidx3 = oidx2 + idx0;
int oidx4 = oidx3 + idx0;
out[oidx1] = tr2 + tr3;
out[oidx1 + 1] = ti2 + ti3;
out[oidx2] = tr1 + isign * tr4;
out[oidx2 + 1] = ti1 + isign * ti4;
out[oidx3] = tr2 - tr3;
out[oidx3 + 1] = ti2 - ti3;
out[oidx4] = tr1 - isign * tr4;
out[oidx4 + 1] = ti1 - isign * ti4;
}
} else {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = in_off + 1 + 4 * idx1;
for (int i = 0; i < ido - 1; i += 2) {
int iidx1 = i + idx2;
int iidx2 = iidx1 + ido;
int iidx3 = iidx2 + ido;
int iidx4 = iidx3 + ido;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
ti1 = i1r - i3r;
ti2 = i1r + i3r;
ti3 = i2r + i4r;
tr4 = i4r - i2r;
tr1 = i1i - i3i;
tr2 = i1i + i3i;
ti4 = i2i - i4i;
tr3 = i2i + i4i;
cr3 = tr2 - tr3;
ci3 = ti2 - ti3;
cr2 = tr1 + isign * tr4;
cr4 = tr1 - isign * tr4;
ci2 = ti1 + isign * ti4;
ci4 = ti1 - isign * ti4;
int widx1 = i + iw1;
int widx2 = i + iw2;
int widx3 = i + iw3;
float w1r = wtable[widx1];
float w1i = isign * wtable[widx1 + 1];
float w2r = wtable[widx2];
float w2i = isign * wtable[widx2 + 1];
float w3r = wtable[widx3];
float w3i = isign * wtable[widx3 + 1];
int oidx1 = out_off + i + idx1;
int oidx2 = oidx1 + idx0;
int oidx3 = oidx2 + idx0;
int oidx4 = oidx3 + idx0;
out[oidx1] = tr2 + tr3;
out[oidx1 + 1] = ti2 + ti3;
out[oidx2] = w1r * cr2 - w1i * ci2;
out[oidx2 + 1] = w1r * ci2 + w1i * cr2;
out[oidx3] = w2r * cr3 - w2i * ci3;
out[oidx3 + 1] = w2r * ci3 + w2i * cr3;
out[oidx4] = w3r * cr4 - w3i * ci4;
out[oidx4 + 1] = w3r * ci4 + w3i * cr4;
}
}
}
}
/*----------------------------------------------------------------------
passf5: Complex FFT's forward/backward processing of factor 5;
isign is +1 for backward and -1 for forward transforms
---------------------------------------------------------------------- | FloatFFT::passf5 | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
void passfg(final int[] nac, final int ido, final int ip, final int l1, final int idl1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset, final int isign) {
int idij, idlj, idot, ipph, l, jc, lc, idj, idl, inc, idp;
float w1r, w1i, w2i, w2r;
int iw1;
iw1 = offset;
idot = ido / 2;
ipph = (ip + 1) / 2;
idp = ip * ido;
if (ido >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * ido;
int idx2 = jc * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int idx4 = idx3 + idx1 * l1;
int idx5 = idx3 + idx2 * l1;
int idx6 = idx3 * ip;
for (int i = 0; i < ido; i++) {
int oidx1 = out_off + i;
float i1r = in[in_off + i + idx1 + idx6];
float i2r = in[in_off + i + idx2 + idx6];
out[oidx1 + idx4] = i1r + i2r;
out[oidx1 + idx5] = i1r - i2r;
}
}
}
for (int k = 0; k < l1; k++) {
int idxt1 = k * ido;
int idxt2 = idxt1 * ip;
for (int i = 0; i < ido; i++) {
out[out_off + i + idxt1] = in[in_off + i + idxt2];
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idxt1 = j * l1 * ido;
int idxt2 = jc * l1 * ido;
int idxt3 = j * ido;
int idxt4 = jc * ido;
for (int i = 0; i < ido; i++) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = idx1 * ip;
int idx3 = out_off + i;
int idx4 = in_off + i;
float i1r = in[idx4 + idxt3 + idx2];
float i2r = in[idx4 + idxt4 + idx2];
out[idx3 + idx1 + idxt1] = i1r + i2r;
out[idx3 + idx1 + idxt2] = i1r - i2r;
}
}
}
for (int i = 0; i < ido; i++) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
out[out_off + i + idx1] = in[in_off + i + idx1 * ip];
}
}
}
idl = 2 - ido;
inc = 0;
int idxt0 = (ip - 1) * idl1;
for (l = 1; l < ipph; l++) {
lc = ip - l;
idl += ido;
int idxt1 = l * idl1;
int idxt2 = lc * idl1;
int idxt3 = idl + iw1;
w1r = wtable[idxt3 - 2];
w1i = isign * wtable[idxt3 - 1];
for (int ik = 0; ik < idl1; ik++) {
int idx1 = in_off + ik;
int idx2 = out_off + ik;
in[idx1 + idxt1] = out[idx2] + w1r * out[idx2 + idl1];
in[idx1 + idxt2] = w1i * out[idx2 + idxt0];
}
idlj = idl;
inc += ido;
for (int j = 2; j < ipph; j++) {
jc = ip - j;
idlj += inc;
if (idlj > idp)
idlj -= idp;
int idxt4 = idlj + iw1;
w2r = wtable[idxt4 - 2];
w2i = isign * wtable[idxt4 - 1];
int idxt5 = j * idl1;
int idxt6 = jc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx1 = in_off + ik;
int idx2 = out_off + ik;
in[idx1 + idxt1] += w2r * out[idx2 + idxt5];
in[idx1 + idxt2] += w2i * out[idx2 + idxt6];
}
}
}
for (int j = 1; j < ipph; j++) {
int idxt1 = j * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx1 = out_off + ik;
out[idx1] += out[idx1 + idxt1];
}
}
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * idl1;
int idx2 = jc * idl1;
for (int ik = 1; ik < idl1; ik += 2) {
int idx3 = out_off + ik;
int idx4 = in_off + ik;
int iidx1 = idx4 + idx1;
int iidx2 = idx4 + idx2;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
int oidx1 = idx3 + idx1;
int oidx2 = idx3 + idx2;
out[oidx1 - 1] = i1i - i2r;
out[oidx2 - 1] = i1i + i2r;
out[oidx1] = i1r + i2i;
out[oidx2] = i1r - i2i;
}
}
nac[0] = 1;
if (ido == 2)
return;
nac[0] = 0;
System.arraycopy(out, out_off, in, in_off, idl1);
int idx0 = l1 * ido;
for (int j = 1; j < ip; j++) {
int idx1 = j * idx0;
for (int k = 0; k < l1; k++) {
int idx2 = k * ido;
int oidx1 = out_off + idx2 + idx1;
int iidx1 = in_off + idx2 + idx1;
in[iidx1] = out[oidx1];
in[iidx1 + 1] = out[oidx1 + 1];
}
}
if (idot <= l1) {
idij = 0;
for (int j = 1; j < ip; j++) {
idij += 2;
int idx1 = j * l1 * ido;
for (int i = 3; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1 - 1;
w1r = wtable[idx2 - 1];
w1i = isign * wtable[idx2];
int idx3 = in_off + i;
int idx4 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx5 = k * ido + idx1;
int iidx1 = idx3 + idx5;
int oidx1 = idx4 + idx5;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
in[iidx1 - 1] = w1r * o1i - w1i * o1r;
in[iidx1] = w1r * o1r + w1i * o1i;
}
}
}
} else {
idj = 2 - ido;
for (int j = 1; j < ip; j++) {
idj += ido;
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
idij = idj;
int idx3 = k * ido + idx1;
for (int i = 3; i < ido; i += 2) {
idij += 2;
int idx2 = idij - 1 + iw1;
w1r = wtable[idx2 - 1];
w1i = isign * wtable[idx2];
int iidx1 = in_off + i + idx3;
int oidx1 = out_off + i + idx3;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
in[iidx1 - 1] = w1r * o1i - w1i * o1r;
in[iidx1] = w1r * o1r + w1i * o1i;
}
}
}
}
} |
Computes 1D inverse DFT of real data leaving the result in <code>a</code>
. This method computes the full real inverse transform, i.e. you will get
the same result as from <code>complexInverse</code> called with all
imaginary part equal 0. Because the result is stored in <code>a</code>,
the size of the input array must greater or equal 2*n, with only the
first n elements filled with real data.
@param a
data to transform
@param offa
index of the first element in array <code>a</code>
@param scale
if true then scaling is performed
public void realInverseFull(final float[] a, final int offa, boolean scale) {
final int twon = 2 * n;
switch (plan) {
case SPLIT_RADIX:
realInverse2(a, offa, scale);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n / 2 > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
Future<?>[] futures = new Future[nthreads];
int k = n / 2 / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n / 2 : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
int idx1, idx2;
for (int k = firstIdx; k < lastIdx; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
int idx1, idx2;
for (int k = 0; k < n / 2; k++) {
idx1 = 2 * k;
idx2 = offa + ((twon - idx1) % twon);
a[idx2] = a[offa + idx1];
a[idx2 + 1] = -a[offa + idx1 + 1];
}
}
a[offa + n] = -a[offa + 1];
a[offa + 1] = 0;
break;
case MIXED_RADIX:
rfftf(a, offa);
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
} else {
m = (n + 1) / 2;
}
for (int k = 1; k < m; k++) {
int idx1 = offa + 2 * k;
int idx2 = offa + twon - 2 * k;
a[idx1] = -a[idx1];
a[idx2 + 1] = -a[idx1];
a[idx2] = a[idx1 - 1];
}
for (int k = 1; k < n; k++) {
int idx = offa + n - k;
float tmp = a[idx + 1];
a[idx + 1] = a[idx];
a[idx] = tmp;
}
a[offa + 1] = 0;
break;
case BLUESTEIN:
bluestein_real_full(a, offa, 1);
if (scale) {
scale(n, a, offa, true);
}
break;
}
}
private void realInverse2(float[] a, int offa, boolean scale) {
if (n == 1)
return;
switch (plan) {
case SPLIT_RADIX:
float xi;
if (n > 4) {
cftfsub(n, a, offa, ip, nw, w);
rftbsub(n, a, offa, nc, w, nw);
} else if (n == 4) {
cftbsub(n, a, offa, ip, nw, w);
}
xi = a[offa] - a[offa + 1];
a[offa] += a[offa + 1];
a[offa + 1] = xi;
if (scale) {
scale(n, a, offa, false);
}
break;
case MIXED_RADIX:
rfftf(a, offa);
for (int k = n - 1; k >= 2; k--) {
int idx = offa + k;
float tmp = a[idx];
a[idx] = a[idx - 1];
a[idx - 1] = tmp;
}
if (scale) {
scale(n, a, offa, false);
}
int m;
if (n % 2 == 0) {
m = n / 2;
for (int i = 1; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
} else {
m = (n - 1) / 2;
for (int i = 0; i < m; i++) {
int idx = offa + 2 * i + 1;
a[idx] = -a[idx];
}
}
break;
case BLUESTEIN:
bluestein_real_inverse2(a, offa);
if (scale) {
scale(n, a, offa, false);
}
break;
}
}
private static int getReminder(int n, int[] factors) {
int reminder = n;
if (n <= 0) {
throw new IllegalArgumentException("n must be positive integer");
}
for (int i = 0; i < factors.length && reminder != 1; i++) {
int factor = factors[i];
while ((reminder % factor) == 0) {
reminder /= factor;
}
}
return reminder;
}
/* -------- initializing routines --------
/*---------------------------------------------------------
cffti: initialization of Complex FFT
--------------------------------------------------------
void cffti(int n, int offw) {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[offw + nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[offw + idx + 1] = wtable[offw + idx];
}
wtable[offw + 2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[offw + fourn] = n;
wtable[offw + 1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[offw + k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[offw + i - 1 + twon] = 1;
wtable[offw + i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[offw + idx - 1] = (float)Math.cos(arg);
wtable[offw + idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[offw + idx1 - 1] = wtable[offw + idx2 - 1];
wtable[offw + idx1] = wtable[offw + idx2];
}
}
l1 = l2;
}
}
void cffti() {
if (n == 1)
return;
final int twon = 2 * n;
final int fourn = 4 * n;
float argh;
int idot, ntry = 0, i, j;
float argld;
int i1, k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, nq, nr;
float arg;
int ido, ipm;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
j++;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
nf++;
wtable[nf + 1 + fourn] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + fourn;
wtable[idx + 1] = wtable[idx];
}
wtable[2 + fourn] = 2;
}
} while (nl != 1);
break;
}
wtable[fourn] = n;
wtable[1 + fourn] = nf;
argh = TWO_PI / (float) n;
i = 1;
l1 = 1;
for (k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable[k1 + 1 + fourn];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
idot = ido + ido + 2;
ipm = ip - 1;
for (j = 1; j <= ipm; j++) {
i1 = i;
wtable[i - 1 + twon] = 1;
wtable[i + twon] = 0;
ld += l1;
fi = 0;
argld = ld * argh;
for (ii = 4; ii <= idot; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + twon;
wtable[idx - 1] = (float)Math.cos(arg);
wtable[idx] = (float)Math.sin(arg);
}
if (ip > 5) {
int idx1 = i1 + twon;
int idx2 = i + twon;
wtable[idx1 - 1] = wtable[idx2 - 1];
wtable[idx1] = wtable[idx2];
}
}
l1 = l2;
}
}
void rffti() {
if (n == 1)
return;
final int twon = 2 * n;
float argh;
int ntry = 0, i, j;
float argld;
int k1, l1, l2, ib;
float fi;
int ld, ii, nf, ip, nl, is, nq, nr;
float arg;
int ido, ipm;
int nfm1;
nl = n;
nf = 0;
j = 0;
factorize_loop: while (true) {
++j;
if (j <= 4)
ntry = factors[j - 1];
else
ntry += 2;
do {
nq = nl / ntry;
nr = nl - ntry * nq;
if (nr != 0)
continue factorize_loop;
++nf;
wtable_r[nf + 1 + twon] = ntry;
nl = nq;
if (ntry == 2 && nf != 1) {
for (i = 2; i <= nf; i++) {
ib = nf - i + 2;
int idx = ib + twon;
wtable_r[idx + 1] = wtable_r[idx];
}
wtable_r[2 + twon] = 2;
}
} while (nl != 1);
break;
}
wtable_r[twon] = n;
wtable_r[1 + twon] = nf;
argh = TWO_PI / (float) (n);
is = 0;
nfm1 = nf - 1;
l1 = 1;
if (nfm1 == 0)
return;
for (k1 = 1; k1 <= nfm1; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
ld = 0;
l2 = l1 * ip;
ido = n / l2;
ipm = ip - 1;
for (j = 1; j <= ipm; ++j) {
ld += l1;
i = is;
argld = (float) ld * argh;
fi = 0;
for (ii = 3; ii <= ido; ii += 2) {
i += 2;
fi += 1;
arg = fi * argld;
int idx = i + n;
wtable_r[idx - 2] = (float)Math.cos(arg);
wtable_r[idx - 1] = (float)Math.sin(arg);
}
is += ido;
}
l1 = l2;
}
}
private void bluesteini() {
int k = 0;
float arg;
float pi_n = PI / n;
bk1[0] = 1;
bk1[1] = 0;
for (int i = 1; i < n; i++) {
k += 2 * i - 1;
if (k >= 2 * n)
k -= 2 * n;
arg = pi_n * k;
bk1[2 * i] = (float)Math.cos(arg);
bk1[2 * i + 1] = (float)Math.sin(arg);
}
float scale = (float)(1.0 / nBluestein);
bk2[0] = bk1[0] * scale;
bk2[1] = bk1[1] * scale;
for (int i = 2; i < 2 * n; i += 2) {
bk2[i] = bk1[i] * scale;
bk2[i + 1] = bk1[i + 1] * scale;
bk2[2 * nBluestein - i] = bk2[i];
bk2[2 * nBluestein - i + 1] = bk2[i + 1];
}
cftbsub(2 * nBluestein, bk2, 0, ip, nw, w);
}
private void makewt(int nw) {
int j, nwh, nw0, nw1;
float delta, wn4r, wk1r, wk1i, wk3r, wk3i;
float delta2, deltaj, deltaj3;
ip[0] = nw;
ip[1] = 1;
if (nw > 2) {
nwh = nw >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nwh);
delta2 = delta * 2;
wn4r = (float)Math.cos(delta * nwh);
w[0] = 1;
w[1] = wn4r;
if (nwh == 4) {
w[2] = (float)Math.cos(delta2);
w[3] = (float)Math.sin(delta2);
} else if (nwh > 4) {
makeipt(nw);
w[2] = (float)(0.5 / Math.cos(delta2));
w[3] = (float)(0.5 / Math.cos(delta * 6));
for (j = 4; j < nwh; j += 4) {
deltaj = delta * j;
deltaj3 = 3 * deltaj;
w[j] = (float)Math.cos(deltaj);
w[j + 1] = (float)Math.sin(deltaj);
w[j + 2] = (float)Math.cos(deltaj3);
w[j + 3] = (float)-Math.sin(deltaj3);
}
}
nw0 = 0;
while (nwh > 2) {
nw1 = nw0 + nwh;
nwh >>= 1;
w[nw1] = 1;
w[nw1 + 1] = wn4r;
if (nwh == 4) {
wk1r = w[nw0 + 4];
wk1i = w[nw0 + 5];
w[nw1 + 2] = wk1r;
w[nw1 + 3] = wk1i;
} else if (nwh > 4) {
wk1r = w[nw0 + 4];
wk3r = w[nw0 + 6];
w[nw1 + 2] = (float)(0.5 / wk1r);
w[nw1 + 3] = (float)(0.5 / wk3r);
for (j = 4; j < nwh; j += 4) {
int idx1 = nw0 + 2 * j;
int idx2 = nw1 + j;
wk1r = w[idx1];
wk1i = w[idx1 + 1];
wk3r = w[idx1 + 2];
wk3i = w[idx1 + 3];
w[idx2] = wk1r;
w[idx2 + 1] = wk1i;
w[idx2 + 2] = wk3r;
w[idx2 + 3] = wk3i;
}
}
nw0 = nw1;
}
}
}
private void makeipt(int nw) {
int j, l, m, m2, p, q;
ip[2] = 0;
ip[3] = 16;
m = 2;
for (l = nw; l > 32; l >>= 2) {
m2 = m << 1;
q = m2 << 3;
for (j = m; j < m2; j++) {
p = ip[j] << 2;
ip[m + j] = p;
ip[m2 + j] = p + q;
}
m = m2;
}
}
private void makect(int nc, float[] c, int startc) {
int j, nch;
float delta, deltaj;
ip[1] = nc;
if (nc > 1) {
nch = nc >> 1;
delta = (float)(0.785398163397448278999490867136046290 / nch);
c[startc] = (float)Math.cos(delta * nch);
c[startc + nch] = (float)(0.5 * c[startc]);
for (j = 1; j < nch; j++) {
deltaj = delta * j;
c[startc + j] = (float)(0.5 * Math.cos(deltaj));
c[startc + nc - j] = (float)(0.5 * Math.sin(deltaj));
}
}
}
private void bluestein_complex(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_full(final float[] a, final int offa, final int isign) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
if (isign > 0) {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (isign > 0) {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
}
}
}
private void bluestein_real_forward(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = -a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] + bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1];
a[offa + 1] = -bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2];
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] + bk1[n] * ak[n];
}
}
private void bluestein_real_inverse(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
if (n % 2 == 0) {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n] = a[offa + 1] * bk1[n];
ak[n + 1] = a[offa + 1] * bk1[n + 1];
for (int i = n / 2 + 1; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
} else {
ak[0] = a[offa] * bk1[0];
ak[1] = a[offa] * bk1[1];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + idx1;
int idx4 = offa + idx2;
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1];
}
ak[n - 1] = a[offa + n - 1] * bk1[n - 1] - a[offa + 1] * bk1[n];
ak[n] = a[offa + n - 1] * bk1[n] + a[offa + 1] * bk1[n - 1];
ak[n + 1] = a[offa + n - 1] * bk1[n + 1] + a[offa + 1] * bk1[n + 2];
ak[n + 2] = a[offa + n - 1] * bk1[n + 2] - a[offa + 1] * bk1[n + 1];
for (int i = (n - 1) / 2 + 2; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + 2 * n - idx1;
int idx4 = idx3 + 1;
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2];
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1];
}
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
}
}
}
private void bluestein_real_inverse2(final float[] a, final int offa) {
final float[] ak = new float[2 * nBluestein];
int nthreads = ConcurrencyUtils.getNumberOfThreads();
if ((nthreads > 1) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_2Threads())) {
nthreads = 2;
if ((nthreads >= 4) && (n > ConcurrencyUtils.getThreadsBeginN_1D_FFT_4Threads())) {
nthreads = 4;
}
Future<?>[] futures = new Future[nthreads];
int k = n / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? n : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
k = nBluestein / nthreads;
for (int i = 0; i < nthreads; i++) {
final int firstIdx = i * k;
final int lastIdx = (i == (nthreads - 1)) ? nBluestein : firstIdx + k;
futures[i] = ConcurrencyUtils.submit(new Runnable() {
public void run() {
for (int i = firstIdx; i < lastIdx; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
});
}
ConcurrencyUtils.waitForCompletion(futures);
} else {
for (int i = 0; i < n; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
int idx3 = offa + i;
ak[idx1] = a[idx3] * bk1[idx1];
ak[idx2] = a[idx3] * bk1[idx2];
}
cftbsub(2 * nBluestein, ak, 0, ip, nw, w);
for (int i = 0; i < nBluestein; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
float im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1];
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2];
ak[idx2] = im;
}
}
cftfsub(2 * nBluestein, ak, 0, ip, nw, w);
if (n % 2 == 0) {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n] - bk1[n + 1] * ak[n + 1];
for (int i = 1; i < n / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
} else {
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1];
a[offa + 1] = bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n];
for (int i = 1; i < (n - 1) / 2; i++) {
int idx1 = 2 * i;
int idx2 = idx1 + 1;
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2];
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2];
}
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] - bk1[n] * ak[n];
}
}
/*---------------------------------------------------------
rfftf1: further processing of Real forward FFT
--------------------------------------------------------
void rfftf(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, kh, nf, ip, iw, ido, idl1;
final float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 1;
l2 = n;
iw = twon - 1;
for (int k1 = 1; k1 <= nf; ++k1) {
kh = nf - k1;
ip = (int) wtable_r[kh + 2 + twon];
l1 = l2 / ip;
ido = n / l2;
idl1 = ido * l1;
iw -= (ip - 1) * ido;
na = 1 - na;
switch (ip) {
case 2:
if (na == 0) {
radf2(ido, l1, a, offa, ch, 0, iw);
} else {
radf2(ido, l1, ch, 0, a, offa, iw);
}
break;
case 3:
if (na == 0) {
radf3(ido, l1, a, offa, ch, 0, iw);
} else {
radf3(ido, l1, ch, 0, a, offa, iw);
}
break;
case 4:
if (na == 0) {
radf4(ido, l1, a, offa, ch, 0, iw);
} else {
radf4(ido, l1, ch, 0, a, offa, iw);
}
break;
case 5:
if (na == 0) {
radf5(ido, l1, a, offa, ch, 0, iw);
} else {
radf5(ido, l1, ch, 0, a, offa, iw);
}
break;
default:
if (ido == 1)
na = 1 - na;
if (na == 0) {
radfg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
na = 1;
} else {
radfg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
na = 0;
}
break;
}
l2 = l1;
}
if (na == 1)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*---------------------------------------------------------
rfftb1: further processing of Real backward FFT
--------------------------------------------------------
void rfftb(final float[] a, final int offa) {
if (n == 1)
return;
int l1, l2, na, nf, ip, iw, ido, idl1;
float[] ch = new float[n];
final int twon = 2 * n;
nf = (int) wtable_r[1 + twon];
na = 0;
l1 = 1;
iw = n;
for (int k1 = 1; k1 <= nf; k1++) {
ip = (int) wtable_r[k1 + 1 + twon];
l2 = ip * l1;
ido = n / l2;
idl1 = ido * l1;
switch (ip) {
case 2:
if (na == 0) {
radb2(ido, l1, a, offa, ch, 0, iw);
} else {
radb2(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
radb3(ido, l1, a, offa, ch, 0, iw);
} else {
radb3(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 4:
if (na == 0) {
radb4(ido, l1, a, offa, ch, 0, iw);
} else {
radb4(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
radb5(ido, l1, a, offa, ch, 0, iw);
} else {
radb5(ido, l1, ch, 0, a, offa, iw);
}
na = 1 - na;
break;
default:
if (na == 0) {
radbg(ido, ip, l1, idl1, a, offa, ch, 0, iw);
} else {
radbg(ido, ip, l1, idl1, ch, 0, a, offa, iw);
}
if (ido == 1)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * ido;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, n);
}
/*-------------------------------------------------
radf2: Real FFT's forward processing of factor 2
-------------------------------------------------
void radf2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic, idx0, idx1, idx2, idx3, idx4;
float t1i, t1r, w1r, w1i;
int iw1;
iw1 = offset;
idx0 = l1 * ido;
idx1 = 2 * ido;
for (int k = 0; k < l1; k++) {
int oidx1 = out_off + k * idx1;
int oidx2 = oidx1 + idx1 - 1;
int iidx1 = in_off + k * ido;
int iidx2 = iidx1 + idx0;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx2] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
idx2 = 2 * idx1;
idx3 = idx2 + ido;
idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int oidx1 = out_off + i + idx2;
int oidx2 = out_off + ic + idx3;
int iidx1 = in_off + i + idx1;
int iidx2 = in_off + i + idx4;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
t1r = w1r * a2i + w1i * a2r;
t1i = w1r * a2r - w1i * a2i;
out[oidx1] = a1r + t1i;
out[oidx1 - 1] = a1i + t1r;
out[oidx2] = t1i - a1r;
out[oidx2 - 1] = a1i - t1r;
}
}
if (ido % 2 == 1)
return;
}
idx2 = 2 * idx1;
for (int k = 0; k < l1; k++) {
idx1 = k * ido;
int oidx1 = out_off + idx2 + ido;
int iidx1 = in_off + ido - 1 + idx1;
out[oidx1] = -in[iidx1 + idx0];
out[oidx1 - 1] = in[iidx1];
}
}
/*-------------------------------------------------
radb2: Real FFT's backward processing of factor 2
-------------------------------------------------
void radb2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int i, ic;
float t1i, t1r, w1r, w1i;
int iw1 = offset;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int oidx1 = out_off + idx1;
int iidx1 = in_off + idx2;
int iidx2 = in_off + ido - 1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1] = i1r + i2r;
out[oidx1 + idx0] = i1r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx1 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx5 = i - 1 + iw1;
int idx6 = out_off + i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
w1r = wtable_r[idx5 - 1];
w1i = wtable_r[idx5];
int iidx1 = idx7 + idx2;
int iidx2 = idx8 + idx3;
int oidx1 = idx6 + idx1;
int oidx2 = idx6 + idx4;
t1r = in[iidx1 - 1] - in[iidx2 - 1];
t1i = in[iidx1] + in[iidx2];
float i1i = in[iidx1];
float i1r = in[iidx1 - 1];
float i2i = in[iidx2];
float i2r = in[iidx2 - 1];
out[oidx1 - 1] = i1r + i2r;
out[oidx1] = i1i - i2i;
out[oidx2 - 1] = w1r * t1r - w1i * t1i;
out[oidx2] = w1r * t1i + w1i * t1r;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 2 * idx1;
int oidx1 = out_off + ido - 1 + idx1;
int iidx1 = in_off + idx2 + ido;
out[oidx1] = 2 * in[iidx1 - 1];
out[oidx1 + idx0] = -2 * in[iidx1];
}
}
/*-------------------------------------------------
radf3: Real FFT's forward processing of factor 3
-------------------------------------------------
void radf3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, di2, di3, cr2, dr2, dr3, ti2, ti3, tr2, tr3, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx3 = 2 * idx0;
int idx4 = (3 * k + 1) * ido;
int iidx1 = in_off + idx1;
int iidx2 = iidx1 + idx0;
int iidx3 = iidx1 + idx3;
float i1r = in[iidx1];
float i2r = in[iidx2];
float i3r = in[iidx3];
cr2 = i2r + i3r;
out[out_off + 3 * idx1] = i1r + cr2;
out[out_off + idx4 + ido] = taui * (i3r - i2r);
out[out_off + ido - 1 + idx4] = i1r + taur * cr2;
}
if (ido == 1)
return;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int idx4 = 3 * idx3;
int idx5 = idx3 + idx0;
int idx6 = idx5 + idx0;
int idx7 = idx4 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx3;
int iidx2 = idx9 + idx5;
int iidx3 = idx9 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
cr2 = dr2 + dr3;
ci2 = di2 + di3;
tr2 = i1i + taur * cr2;
ti2 = i1r + taur * ci2;
tr3 = taui * (di2 - di3);
ti3 = taui * (dr3 - dr2);
int oidx1 = idx10 + idx4;
int oidx2 = idx11 + idx7;
int oidx3 = idx10 + idx8;
out[oidx1 - 1] = i1i + cr2;
out[oidx1] = i1r + ci2;
out[oidx2 - 1] = tr2 - tr3;
out[oidx2] = ti3 - ti2;
out[oidx3 - 1] = tr2 + tr3;
out[oidx3] = ti2 + ti3;
}
}
}
/*-------------------------------------------------
radb3: Real FFT's backward processing of factor 3
-------------------------------------------------
void radb3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
int i, ic;
float ci2, ci3, di2, di3, cr2, cr3, dr2, dr3, ti2, tr2, w1r, w2r, w1i, w2i;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int iidx1 = in_off + 3 * idx1;
int iidx2 = iidx1 + 2 * ido;
float i1i = in[iidx1];
tr2 = 2 * in[iidx2 - 1];
cr2 = i1i + taur * tr2;
ci3 = 2 * taui * in[iidx2];
out[out_off + idx1] = i1i + tr2;
out[out_off + (k + l1) * ido] = cr2 - ci3;
out[out_off + (k + 2 * l1) * ido] = cr2 + ci3;
}
if (ido == 1)
return;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 3 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx1 + idx0;
int idx6 = idx5 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = in_off + i;
int idx8 = in_off + ic;
int idx9 = out_off + i;
int iidx1 = idx7 + idx2;
int iidx2 = idx7 + idx4;
int iidx3 = idx8 + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
tr2 = i2i + i3i;
cr2 = i1i + taur * tr2;
ti2 = i2r - i3r;
ci2 = i1r + taur * ti2;
cr3 = taui * (i2i - i3i);
ci3 = taui * (i2r + i3r);
dr2 = cr2 - ci3;
dr3 = cr2 + ci3;
di2 = ci2 + cr3;
di3 = ci2 - cr3;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
int oidx1 = idx9 + idx1;
int oidx2 = idx9 + idx5;
int oidx3 = idx9 + idx6;
out[oidx1 - 1] = i1i + tr2;
out[oidx1] = i1r + ti2;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
}
}
}
/*-------------------------------------------------
radf4: Real FFT's forward processing of factor 4
-------------------------------------------------
void radf4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float hsqt2 = 0.707106781186547572737310929369414225f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = offset + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx3];
float i3r = in[in_off + idx4];
float i4r = in[in_off + idx5];
tr1 = i2r + i4r;
tr2 = i1r + i3r;
int oidx1 = out_off + idx2;
int oidx2 = out_off + idx6 + ido;
out[oidx1] = tr1 + tr2;
out[oidx2 - 1 + ido + ido] = tr2 - tr1;
out[oidx2 - 1] = i1r - i3r;
out[oidx2] = i4r - i2r;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx9 = in_off + i;
int idx10 = out_off + i;
int idx11 = out_off + ic;
int iidx1 = idx9 + idx1;
int iidx2 = idx9 + idx2;
int iidx3 = idx9 + idx3;
int iidx4 = idx9 + idx4;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
cr2 = w1r * i2i + w1i * i2r;
ci2 = w1r * i2r - w1i * i2i;
cr3 = w2r * i3i + w2i * i3r;
ci3 = w2r * i3r - w2i * i3i;
cr4 = w3r * i4i + w3i * i4r;
ci4 = w3r * i4r - w3i * i4i;
tr1 = cr2 + cr4;
tr4 = cr4 - cr2;
ti1 = ci2 + ci4;
ti4 = ci2 - ci4;
ti2 = i1r + ci3;
ti3 = i1r - ci3;
tr2 = i1i + cr3;
tr3 = i1i - cr3;
int oidx1 = idx10 + idx5;
int oidx2 = idx11 + idx6;
int oidx3 = idx10 + idx7;
int oidx4 = idx11 + idx8;
out[oidx1 - 1] = tr1 + tr2;
out[oidx4 - 1] = tr2 - tr1;
out[oidx1] = ti1 + ti2;
out[oidx4] = ti1 - ti2;
out[oidx3 - 1] = ti4 + tr3;
out[oidx2 - 1] = tr3 - ti4;
out[oidx3] = tr4 + ti3;
out[oidx2] = tr4 - ti3;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1i = in[idx9 - 1 + idx1];
float i2i = in[idx9 - 1 + idx3];
float i3i = in[idx9 - 1 + idx4];
float i4i = in[idx9 - 1 + idx5];
ti1 = -hsqt2 * (i2i + i4i);
tr1 = hsqt2 * (i2i - i4i);
out[idx10 - 1 + idx2] = tr1 + i1i;
out[idx10 - 1 + idx7] = i1i - tr1;
out[out_off + idx6] = ti1 - i3i;
out[out_off + idx8] = ti1 + i3i;
}
}
/*-------------------------------------------------
radb4: Real FFT's backward processing of factor 4
-------------------------------------------------
void radb4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float sqrt2 = 1.41421356237309514547462185873882845f;
int i, ic;
float ci2, ci3, ci4, cr2, cr3, cr4;
float ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
float i1r = in[in_off + idx2];
float i2r = in[in_off + idx7];
float i3r = in[in_off + ido - 1 + idx8];
float i4r = in[in_off + ido - 1 + idx6];
tr1 = i1r - i3r;
tr2 = i1r + i3r;
tr3 = i4r + i4r;
tr4 = i2r + i2r;
out[out_off + idx1] = tr2 + tr3;
out[out_off + idx3] = tr1 - tr4;
out[out_off + idx4] = tr2 - tr3;
out[out_off + idx5] = tr1 + tr4;
}
if (ido < 2)
return;
if (ido != 2) {
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = idx1 + idx0;
int idx3 = idx2 + idx0;
int idx4 = idx3 + idx0;
int idx5 = 4 * idx1;
int idx6 = idx5 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
int idx12 = in_off + i;
int idx13 = in_off + ic;
int idx14 = out_off + i;
int iidx1 = idx12 + idx5;
int iidx2 = idx13 + idx6;
int iidx3 = idx12 + idx7;
int iidx4 = idx13 + idx8;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
ti1 = i1r + i4r;
ti2 = i1r - i4r;
ti3 = i3r - i2r;
tr4 = i3r + i2r;
tr1 = i1i - i4i;
tr2 = i1i + i4i;
ti4 = i3i - i2i;
tr3 = i3i + i2i;
cr3 = tr2 - tr3;
ci3 = ti2 - ti3;
cr2 = tr1 - tr4;
cr4 = tr1 + tr4;
ci2 = ti1 + ti4;
ci4 = ti1 - ti4;
int oidx1 = idx14 + idx1;
int oidx2 = idx14 + idx2;
int oidx3 = idx14 + idx3;
int oidx4 = idx14 + idx4;
out[oidx1 - 1] = tr2 + tr3;
out[oidx1] = ti2 + ti3;
out[oidx2 - 1] = w1r * cr2 - w1i * ci2;
out[oidx2] = w1r * ci2 + w1i * cr2;
out[oidx3 - 1] = w2r * cr3 - w2i * ci3;
out[oidx3] = w2r * ci3 + w2i * cr3;
out[oidx4 - 1] = w3r * cr4 - w3i * ci4;
out[oidx4] = w3r * ci4 + w3i * cr4;
}
}
if (ido % 2 == 1)
return;
}
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 4 * idx1;
int idx3 = idx1 + idx0;
int idx4 = idx3 + idx0;
int idx5 = idx4 + idx0;
int idx6 = idx2 + ido;
int idx7 = idx6 + ido;
int idx8 = idx7 + ido;
int idx9 = in_off + ido;
int idx10 = out_off + ido;
float i1r = in[idx9 - 1 + idx2];
float i2r = in[idx9 - 1 + idx7];
float i3r = in[in_off + idx6];
float i4r = in[in_off + idx8];
ti1 = i3r + i4r;
ti2 = i4r - i3r;
tr1 = i1r - i2r;
tr2 = i1r + i2r;
out[idx10 - 1 + idx1] = tr2 + tr2;
out[idx10 - 1 + idx3] = sqrt2 * (tr1 - ti1);
out[idx10 - 1 + idx4] = ti2 + ti2;
out[idx10 - 1 + idx5] = -sqrt2 * (tr1 + ti1);
}
}
/*-------------------------------------------------
radf5: Real FFT's forward processing of factor 5
-------------------------------------------------
void radf5(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float tr11 = 0.309016994374947451262869435595348477f;
final float ti11 = 0.951056516295153531181938433292089030f;
final float tr12 = -0.809016994374947340240566973079694435f;
final float ti12 = 0.587785252292473248125759255344746634f;
int i, ic;
float ci2, di2, ci4, ci5, di3, di4, di5, ci3, cr2, cr3, dr2, dr3, dr4, dr5, cr5, cr4, ti2, ti3, ti5, ti4, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
int iw1, iw2, iw3, iw4;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
iw4 = iw3 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
int idx11 = out_off + ido - 1;
float i1r = in[in_off + idx1];
float i2r = in[in_off + idx7];
float i3r = in[in_off + idx8];
float i4r = in[in_off + idx9];
float i5r = in[in_off + idx10];
cr2 = i5r + i2r;
ci5 = i5r - i2r;
cr3 = i4r + i3r;
ci4 = i4r - i3r;
out[out_off + idx2] = i1r + cr2 + cr3;
out[idx11 + idx3] = i1r + tr11 * cr2 + tr12 * cr3;
out[out_off + idx4] = ti11 * ci5 + ti12 * ci4;
out[idx11 + idx5] = i1r + tr12 * cr2 + tr11 * cr3;
out[out_off + idx6] = ti12 * ci5 - ti11 * ci4;
}
if (ido == 1)
return;
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
for (i = 2; i < ido; i += 2) {
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
int widx4 = i - 1 + iw4;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
w4r = wtable_r[widx4 - 1];
w4i = wtable_r[widx4];
ic = ido - i;
int idx15 = in_off + i;
int idx16 = out_off + i;
int idx17 = out_off + ic;
int iidx1 = idx15 + idx1;
int iidx2 = idx15 + idx7;
int iidx3 = idx15 + idx8;
int iidx4 = idx15 + idx9;
int iidx5 = idx15 + idx10;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
dr2 = w1r * i2i + w1i * i2r;
di2 = w1r * i2r - w1i * i2i;
dr3 = w2r * i3i + w2i * i3r;
di3 = w2r * i3r - w2i * i3i;
dr4 = w3r * i4i + w3i * i4r;
di4 = w3r * i4r - w3i * i4i;
dr5 = w4r * i5i + w4i * i5r;
di5 = w4r * i5r - w4i * i5i;
cr2 = dr2 + dr5;
ci5 = dr5 - dr2;
cr5 = di2 - di5;
ci2 = di2 + di5;
cr3 = dr3 + dr4;
ci4 = dr4 - dr3;
cr4 = di3 - di4;
ci3 = di3 + di4;
tr2 = i1i + tr11 * cr2 + tr12 * cr3;
ti2 = i1r + tr11 * ci2 + tr12 * ci3;
tr3 = i1i + tr12 * cr2 + tr11 * cr3;
ti3 = i1r + tr12 * ci2 + tr11 * ci3;
tr5 = ti11 * cr5 + ti12 * cr4;
ti5 = ti11 * ci5 + ti12 * ci4;
tr4 = ti12 * cr5 - ti11 * cr4;
ti4 = ti12 * ci5 - ti11 * ci4;
int oidx1 = idx16 + idx2;
int oidx2 = idx17 + idx3;
int oidx3 = idx16 + idx4;
int oidx4 = idx17 + idx5;
int oidx5 = idx16 + idx6;
out[oidx1 - 1] = i1i + cr2 + cr3;
out[oidx1] = i1r + ci2 + ci3;
out[oidx3 - 1] = tr2 + tr5;
out[oidx2 - 1] = tr2 - tr5;
out[oidx3] = ti2 + ti5;
out[oidx2] = ti5 - ti2;
out[oidx5 - 1] = tr3 + tr4;
out[oidx4 - 1] = tr3 - tr4;
out[oidx5] = ti3 + ti4;
out[oidx4] = ti4 - ti3;
}
}
}
/*-------------------------------------------------
radb5: Real FFT's backward processing of factor 5
-------------------------------------------------
void radb5(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
final float tr11 = 0.309016994374947451262869435595348477f;
final float ti11 = 0.951056516295153531181938433292089030f;
final float tr12 = -0.809016994374947340240566973079694435f;
final float ti12 = 0.587785252292473248125759255344746634f;
int i, ic;
float ci2, ci3, ci4, ci5, di3, di4, di5, di2, cr2, cr3, cr5, cr4, ti2, ti3, ti4, ti5, dr3, dr4, dr5, dr2, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i;
int iw1, iw2, iw3, iw4;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
iw4 = iw3 + ido;
int idx0 = l1 * ido;
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
int idx11 = in_off + ido - 1;
float i1r = in[in_off + idx2];
ti5 = 2 * in[in_off + idx4];
ti4 = 2 * in[in_off + idx6];
tr2 = 2 * in[idx11 + idx3];
tr3 = 2 * in[idx11 + idx5];
cr2 = i1r + tr11 * tr2 + tr12 * tr3;
cr3 = i1r + tr12 * tr2 + tr11 * tr3;
ci5 = ti11 * ti5 + ti12 * ti4;
ci4 = ti12 * ti5 - ti11 * ti4;
out[out_off + idx1] = i1r + tr2 + tr3;
out[out_off + idx7] = cr2 - ci5;
out[out_off + idx8] = cr3 - ci4;
out[out_off + idx9] = cr3 + ci4;
out[out_off + idx10] = cr2 + ci5;
}
if (ido == 1)
return;
for (int k = 0; k < l1; ++k) {
int idx1 = k * ido;
int idx2 = 5 * idx1;
int idx3 = idx2 + ido;
int idx4 = idx3 + ido;
int idx5 = idx4 + ido;
int idx6 = idx5 + ido;
int idx7 = idx1 + idx0;
int idx8 = idx7 + idx0;
int idx9 = idx8 + idx0;
int idx10 = idx9 + idx0;
for (i = 2; i < ido; i += 2) {
ic = ido - i;
int widx1 = i - 1 + iw1;
int widx2 = i - 1 + iw2;
int widx3 = i - 1 + iw3;
int widx4 = i - 1 + iw4;
w1r = wtable_r[widx1 - 1];
w1i = wtable_r[widx1];
w2r = wtable_r[widx2 - 1];
w2i = wtable_r[widx2];
w3r = wtable_r[widx3 - 1];
w3i = wtable_r[widx3];
w4r = wtable_r[widx4 - 1];
w4i = wtable_r[widx4];
int idx15 = in_off + i;
int idx16 = in_off + ic;
int idx17 = out_off + i;
int iidx1 = idx15 + idx2;
int iidx2 = idx16 + idx3;
int iidx3 = idx15 + idx4;
int iidx4 = idx16 + idx5;
int iidx5 = idx15 + idx6;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
ti5 = i3r + i2r;
ti2 = i3r - i2r;
ti4 = i5r + i4r;
ti3 = i5r - i4r;
tr5 = i3i - i2i;
tr2 = i3i + i2i;
tr4 = i5i - i4i;
tr3 = i5i + i4i;
cr2 = i1i + tr11 * tr2 + tr12 * tr3;
ci2 = i1r + tr11 * ti2 + tr12 * ti3;
cr3 = i1i + tr12 * tr2 + tr11 * tr3;
ci3 = i1r + tr12 * ti2 + tr11 * ti3;
cr5 = ti11 * tr5 + ti12 * tr4;
ci5 = ti11 * ti5 + ti12 * ti4;
cr4 = ti12 * tr5 - ti11 * tr4;
ci4 = ti12 * ti5 - ti11 * ti4;
dr3 = cr3 - ci4;
dr4 = cr3 + ci4;
di3 = ci3 + cr4;
di4 = ci3 - cr4;
dr5 = cr2 + ci5;
dr2 = cr2 - ci5;
di5 = ci2 - cr5;
di2 = ci2 + cr5;
int oidx1 = idx17 + idx1;
int oidx2 = idx17 + idx7;
int oidx3 = idx17 + idx8;
int oidx4 = idx17 + idx9;
int oidx5 = idx17 + idx10;
out[oidx1 - 1] = i1i + tr2 + tr3;
out[oidx1] = i1r + ti2 + ti3;
out[oidx2 - 1] = w1r * dr2 - w1i * di2;
out[oidx2] = w1r * di2 + w1i * dr2;
out[oidx3 - 1] = w2r * dr3 - w2i * di3;
out[oidx3] = w2r * di3 + w2i * dr3;
out[oidx4 - 1] = w3r * dr4 - w3i * di4;
out[oidx4] = w3r * di4 + w3i * dr4;
out[oidx5 - 1] = w4r * dr5 - w4i * di5;
out[oidx5] = w4r * di5 + w4i * dr5;
}
}
}
/*---------------------------------------------------------
radfg: Real FFT's forward processing of general factor
--------------------------------------------------------
void radfg(final int ido, final int ip, final int l1, final int idl1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int idij, ipph, j2, ic, jc, lc, is, nbd;
float dc2, ai1, ai2, ar1, ar2, ds2, dcp, arg, dsp, ar1h, ar2h, w1r, w1i;
int iw1 = offset;
arg = TWO_PI / (float) ip;
dcp = (float)Math.cos(arg);
dsp = (float)Math.sin(arg);
ipph = (ip + 1) / 2;
nbd = (ido - 1) / 2;
if (ido != 1) {
if (idl1 >= 0) System.arraycopy(in, in_off, out, out_off, idl1);
for (int j = 1; j < ip; j++) {
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx2 = k * ido + idx1;
out[out_off + idx2] = in[in_off + idx2];
}
}
if (nbd <= l1) {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
idij = is - 1;
int idx1 = j * l1 * ido;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
int idx4 = in_off + i;
int idx5 = out_off + i;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int oidx1 = idx5 + idx3;
int iidx1 = idx4 + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
out[oidx1 - 1] = w1r * i1i + w1i * i1r;
out[oidx1] = w1r * i1r - w1i * i1i;
}
}
}
} else {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
idij = is - 1;
int idx3 = k * ido + idx1;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
int oidx1 = out_off + i + idx3;
int iidx1 = in_off + i + idx3;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
out[oidx1 - 1] = w1r * i1i + w1i * i1r;
out[oidx1] = w1r * i1r - w1i * i1i;
}
}
}
}
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
for (int i = 2; i < ido; i += 2) {
int idx5 = in_off + i;
int idx6 = out_off + i;
int iidx1 = idx5 + idx3;
int iidx2 = idx5 + idx4;
int oidx1 = idx6 + idx3;
int oidx2 = idx6 + idx4;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx1] = o1r + o2r;
in[iidx2 - 1] = o1r - o2r;
in[iidx2] = o2i - o1i;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int i = 2; i < ido; i += 2) {
int idx5 = in_off + i;
int idx6 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
int iidx1 = idx5 + idx3;
int iidx2 = idx5 + idx4;
int oidx1 = idx6 + idx3;
int oidx2 = idx6 + idx4;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx1] = o1r + o2r;
in[iidx2 - 1] = o1r - o2r;
in[iidx2] = o2i - o1i;
}
}
}
}
} else {
System.arraycopy(out, out_off, in, in_off, idl1);
}
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int idx4 = k * ido + idx2;
int oidx1 = out_off + idx3;
int oidx2 = out_off + idx4;
float o1r = out[oidx1];
float o2r = out[oidx2];
in[in_off + idx3] = o1r + o2r;
in[in_off + idx4] = o2r - o1r;
}
}
ar1 = 1;
ai1 = 0;
int idx0 = (ip - 1) * idl1;
for (int l = 1; l < ipph; l++) {
lc = ip - l;
ar1h = dcp * ar1 - dsp * ai1;
ai1 = dcp * ai1 + dsp * ar1;
ar1 = ar1h;
int idx1 = l * idl1;
int idx2 = lc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx3 = out_off + ik;
int idx4 = in_off + ik;
out[idx3 + idx1] = in[idx4] + ar1 * in[idx4 + idl1];
out[idx3 + idx2] = ai1 * in[idx4 + idx0];
}
dc2 = ar1;
ds2 = ai1;
ar2 = ar1;
ai2 = ai1;
for (int j = 2; j < ipph; j++) {
jc = ip - j;
ar2h = dc2 * ar2 - ds2 * ai2;
ai2 = dc2 * ai2 + ds2 * ar2;
ar2 = ar2h;
int idx3 = j * idl1;
int idx4 = jc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx5 = out_off + ik;
int idx6 = in_off + ik;
out[idx5 + idx1] += ar2 * in[idx6 + idx3];
out[idx5 + idx2] += ai2 * in[idx6 + idx4];
}
}
}
for (int j = 1; j < ipph; j++) {
int idx1 = j * idl1;
for (int ik = 0; ik < idl1; ik++) {
out[out_off + ik] += in[in_off + ik + idx1];
}
}
if (ido >= l1) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = idx1 * ip;
for (int i = 0; i < ido; i++) {
in[in_off + i + idx2] = out[out_off + i + idx1];
}
}
} else {
for (int i = 0; i < ido; i++) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
in[in_off + i + idx1 * ip] = out[out_off + i + idx1];
}
}
}
int idx01 = ip * ido;
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido;
int idx5 = idx4 + idx1;
int idx6 = idx4 + idx2;
int idx7 = k * idx01;
in[in_off + ido - 1 + idx3 - ido + idx7] = out[out_off + idx5];
in[in_off + idx3 + idx7] = out[out_off + idx6];
}
}
if (ido == 1)
return;
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * idx01;
int idx5 = k * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx6 = in_off + i;
int idx7 = in_off + ic;
int idx8 = out_off + i;
int iidx1 = idx6 + idx3 + idx4;
int iidx2 = idx7 + idx3 - ido + idx4;
int oidx1 = idx8 + idx5 + idx1;
int oidx2 = idx8 + idx5 + idx2;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx2 - 1] = o1i - o2i;
in[iidx1] = o1r + o2r;
in[iidx2] = o2r - o1r;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx6 = in_off + i;
int idx7 = in_off + ic;
int idx8 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx4 = k * idx01;
int idx5 = k * ido;
int iidx1 = idx6 + idx3 + idx4;
int iidx2 = idx7 + idx3 - ido + idx4;
int oidx1 = idx8 + idx5 + idx1;
int oidx2 = idx8 + idx5 + idx2;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
float o2i = out[oidx2 - 1];
float o2r = out[oidx2];
in[iidx1 - 1] = o1i + o2i;
in[iidx2 - 1] = o1i - o2i;
in[iidx1] = o1r + o2r;
in[iidx2] = o2r - o1r;
}
}
}
}
}
/*---------------------------------------------------------
radbg: Real FFT's backward processing of general factor
--------------------------------------------------------
void radbg(final int ido, final int ip, final int l1, final int idl1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset) {
int idij, ipph, j2, ic, jc, lc, is;
float dc2, ai1, ai2, ar1, ar2, ds2, w1r, w1i;
int nbd;
float dcp, arg, dsp, ar1h, ar2h;
int iw1 = offset;
arg = TWO_PI / (float) ip;
dcp = (float)Math.cos(arg);
dsp = (float)Math.sin(arg);
nbd = (ido - 1) / 2;
ipph = (ip + 1) / 2;
int idx0 = ip * ido;
if (ido >= l1) {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = k * idx0;
for (int i = 0; i < ido; i++) {
out[out_off + i + idx1] = in[in_off + i + idx2];
}
}
} else {
for (int i = 0; i < ido; i++) {
int idx1 = out_off + i;
int idx2 = in_off + i;
for (int k = 0; k < l1; k++) {
out[idx1 + k * ido] = in[idx2 + k * idx0];
}
}
}
int iidx0 = in_off + ido - 1;
for (int j = 1; j < ipph; j++) {
jc = ip - j;
j2 = 2 * j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = j2 * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido;
int idx5 = idx4 * ip;
int iidx1 = iidx0 + idx3 + idx5 - ido;
int iidx2 = in_off + idx3 + idx5;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[out_off + idx4 + idx1] = i1r + i1r;
out[out_off + idx4 + idx2] = i2r + i2r;
}
}
if (ido != 1) {
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = 2 * j * ido;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido + idx1;
int idx5 = k * ido + idx2;
int idx6 = k * ip * ido + idx3;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = out_off + i;
int idx8 = in_off + ic;
int idx9 = in_off + i;
int oidx1 = idx7 + idx4;
int oidx2 = idx7 + idx5;
int iidx1 = idx9 + idx6;
int iidx2 = idx8 + idx6 - ido;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
out[oidx1 - 1] = a1i + a2i;
out[oidx2 - 1] = a1i - a2i;
out[oidx1] = a1r - a2r;
out[oidx2] = a1r + a2r;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
int idx3 = 2 * j * ido;
for (int i = 2; i < ido; i += 2) {
ic = ido - i;
int idx7 = out_off + i;
int idx8 = in_off + ic;
int idx9 = in_off + i;
for (int k = 0; k < l1; k++) {
int idx4 = k * ido + idx1;
int idx5 = k * ido + idx2;
int idx6 = k * ip * ido + idx3;
int oidx1 = idx7 + idx4;
int oidx2 = idx7 + idx5;
int iidx1 = idx9 + idx6;
int iidx2 = idx8 + idx6 - ido;
float a1i = in[iidx1 - 1];
float a1r = in[iidx1];
float a2i = in[iidx2 - 1];
float a2r = in[iidx2];
out[oidx1 - 1] = a1i + a2i;
out[oidx2 - 1] = a1i - a2i;
out[oidx1] = a1r - a2r;
out[oidx2] = a1r + a2r;
}
}
}
}
}
ar1 = 1;
ai1 = 0;
int idx01 = (ip - 1) * idl1;
for (int l = 1; l < ipph; l++) {
lc = ip - l;
ar1h = dcp * ar1 - dsp * ai1;
ai1 = dcp * ai1 + dsp * ar1;
ar1 = ar1h;
int idx1 = l * idl1;
int idx2 = lc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx3 = in_off + ik;
int idx4 = out_off + ik;
in[idx3 + idx1] = out[idx4] + ar1 * out[idx4 + idl1];
in[idx3 + idx2] = ai1 * out[idx4 + idx01];
}
dc2 = ar1;
ds2 = ai1;
ar2 = ar1;
ai2 = ai1;
for (int j = 2; j < ipph; j++) {
jc = ip - j;
ar2h = dc2 * ar2 - ds2 * ai2;
ai2 = dc2 * ai2 + ds2 * ar2;
ar2 = ar2h;
int idx5 = j * idl1;
int idx6 = jc * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx7 = in_off + ik;
int idx8 = out_off + ik;
in[idx7 + idx1] += ar2 * out[idx8 + idx5];
in[idx7 + idx2] += ai2 * out[idx8 + idx6];
}
}
}
for (int j = 1; j < ipph; j++) {
int idx1 = j * idl1;
for (int ik = 0; ik < idl1; ik++) {
int idx2 = out_off + ik;
out[idx2] += out[idx2 + idx1];
}
}
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int oidx1 = out_off + idx3;
int iidx1 = in_off + idx3 + idx1;
int iidx2 = in_off + idx3 + idx2;
float i1r = in[iidx1];
float i2r = in[iidx2];
out[oidx1 + idx1] = i1r - i2r;
out[oidx1 + idx2] = i1r + i2r;
}
}
if (ido == 1)
return;
if (nbd >= l1) {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
for (int i = 2; i < ido; i += 2) {
int idx4 = out_off + i;
int idx5 = in_off + i;
int oidx1 = idx4 + idx3 + idx1;
int oidx2 = idx4 + idx3 + idx2;
int iidx1 = idx5 + idx3 + idx1;
int iidx2 = idx5 + idx3 + idx2;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
out[oidx1 - 1] = i1i - i2r;
out[oidx2 - 1] = i1i + i2r;
out[oidx1] = i1r + i2i;
out[oidx2] = i1r - i2i;
}
}
}
} else {
for (int j = 1; j < ipph; j++) {
jc = ip - j;
int idx1 = j * l1 * ido;
int idx2 = jc * l1 * ido;
for (int i = 2; i < ido; i += 2) {
int idx4 = out_off + i;
int idx5 = in_off + i;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido;
int oidx1 = idx4 + idx3 + idx1;
int oidx2 = idx4 + idx3 + idx2;
int iidx1 = idx5 + idx3 + idx1;
int iidx2 = idx5 + idx3 + idx2;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
out[oidx1 - 1] = i1i - i2r;
out[oidx2 - 1] = i1i + i2r;
out[oidx1] = i1r + i2i;
out[oidx2] = i1r - i2i;
}
}
}
}
System.arraycopy(out, out_off, in, in_off, idl1);
for (int j = 1; j < ip; j++) {
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
int idx2 = k * ido + idx1;
in[in_off + idx2] = out[out_off + idx2];
}
}
if (nbd <= l1) {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
idij = is - 1;
int idx1 = j * l1 * ido;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
int idx4 = in_off + i;
int idx5 = out_off + i;
for (int k = 0; k < l1; k++) {
int idx3 = k * ido + idx1;
int iidx1 = idx4 + idx3;
int oidx1 = idx5 + idx3;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
in[iidx1 - 1] = w1r * o1i - w1i * o1r;
in[iidx1] = w1r * o1r + w1i * o1i;
}
}
}
} else {
is = -ido;
for (int j = 1; j < ip; j++) {
is += ido;
int idx1 = j * l1 * ido;
for (int k = 0; k < l1; k++) {
idij = is - 1;
int idx3 = k * ido + idx1;
for (int i = 2; i < ido; i += 2) {
idij += 2;
int idx2 = idij + iw1;
w1r = wtable_r[idx2 - 1];
w1i = wtable_r[idx2];
int idx4 = in_off + i;
int idx5 = out_off + i;
int iidx1 = idx4 + idx3;
int oidx1 = idx5 + idx3;
float o1i = out[oidx1 - 1];
float o1r = out[oidx1];
in[iidx1 - 1] = w1r * o1i - w1i * o1r;
in[iidx1] = w1r * o1r + w1i * o1i;
}
}
}
}
}
/*---------------------------------------------------------
cfftf1: further processing of Complex forward FFT
--------------------------------------------------------
void cfftf(float[] a, int offa, int isign) {
int idot;
int l1, l2;
int na, nf, ip, iw, ido, idl1;
int[] nac = new int[1];
final int twon = 2 * n;
int iw1, iw2;
float[] ch = new float[twon];
iw1 = twon;
iw2 = 4 * n;
nac[0] = 0;
nf = (int) wtable[1 + iw2];
na = 0;
l1 = 1;
iw = iw1;
for (int k1 = 2; k1 <= nf + 1; k1++) {
ip = (int) wtable[k1 + iw2];
l2 = ip * l1;
ido = n / l2;
idot = ido + ido;
idl1 = idot * l1;
switch (ip) {
case 4:
if (na == 0) {
passf4(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf4(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
case 2:
if (na == 0) {
passf2(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf2(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
case 3:
if (na == 0) {
passf3(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf3(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
case 5:
if (na == 0) {
passf5(idot, l1, a, offa, ch, 0, iw, isign);
} else {
passf5(idot, l1, ch, 0, a, offa, iw, isign);
}
na = 1 - na;
break;
default:
if (na == 0) {
passfg(nac, idot, ip, l1, idl1, a, offa, ch, 0, iw, isign);
} else {
passfg(nac, idot, ip, l1, idl1, ch, 0, a, offa, iw, isign);
}
if (nac[0] != 0)
na = 1 - na;
break;
}
l1 = l2;
iw += (ip - 1) * idot;
}
if (na == 0)
return;
System.arraycopy(ch, 0, a, offa, twon);
}
/*----------------------------------------------------------------------
passf2: Complex FFT's forward/backward processing of factor 2;
isign is +1 for backward and -1 for forward transforms
----------------------------------------------------------------------
void passf2(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset, final int isign) {
float t1i, t1r;
int iw1;
iw1 = offset;
int idx = ido * l1;
if (ido <= 2) {
for (int k = 0; k < l1; k++) {
int idx0 = k * ido;
int iidx1 = in_off + 2 * idx0;
int iidx2 = iidx1 + ido;
float a1r = in[iidx1];
float a1i = in[iidx1 + 1];
float a2r = in[iidx2];
float a2i = in[iidx2 + 1];
int oidx1 = out_off + idx0;
int oidx2 = oidx1 + idx;
out[oidx1] = a1r + a2r;
out[oidx1 + 1] = a1i + a2i;
out[oidx2] = a1r - a2r;
out[oidx2 + 1] = a1i - a2i;
}
} else {
for (int k = 0; k < l1; k++) {
for (int i = 0; i < ido - 1; i += 2) {
int idx0 = k * ido;
int iidx1 = in_off + i + 2 * idx0;
int iidx2 = iidx1 + ido;
float i1r = in[iidx1];
float i1i = in[iidx1 + 1];
float i2r = in[iidx2];
float i2i = in[iidx2 + 1];
int widx1 = i + iw1;
float w1r = wtable[widx1];
float w1i = isign * wtable[widx1 + 1];
t1r = i1r - i2r;
t1i = i1i - i2i;
int oidx1 = out_off + i + idx0;
int oidx2 = oidx1 + idx;
out[oidx1] = i1r + i2r;
out[oidx1 + 1] = i1i + i2i;
out[oidx2] = w1r * t1r - w1i * t1i;
out[oidx2 + 1] = w1r * t1i + w1i * t1r;
}
}
}
}
/*----------------------------------------------------------------------
passf3: Complex FFT's forward/backward processing of factor 3;
isign is +1 for backward and -1 for forward transforms
----------------------------------------------------------------------
void passf3(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset, final int isign) {
final float taur = -0.5f;
final float taui = 0.866025403784438707610604524234076962f;
float ci2, ci3, di2, di3, cr2, cr3, dr2, dr3, ti2, tr2;
int iw1, iw2;
iw1 = offset;
iw2 = iw1 + ido;
final int idxt = l1 * ido;
if (ido == 2) {
for (int k = 1; k <= l1; k++) {
int iidx1 = in_off + (3 * k - 2) * ido;
int iidx2 = iidx1 + ido;
int iidx3 = iidx1 - ido;
float i1r = in[iidx1];
float i1i = in[iidx1 + 1];
float i2r = in[iidx2];
float i2i = in[iidx2 + 1];
float i3r = in[iidx3];
float i3i = in[iidx3 + 1];
tr2 = i1r + i2r;
cr2 = i3r + taur * tr2;
ti2 = i1i + i2i;
ci2 = i3i + taur * ti2;
cr3 = isign * taui * (i1r - i2r);
ci3 = isign * taui * (i1i - i2i);
int oidx1 = out_off + (k - 1) * ido;
int oidx2 = oidx1 + idxt;
int oidx3 = oidx2 + idxt;
out[oidx1] = in[iidx3] + tr2;
out[oidx1 + 1] = i3i + ti2;
out[oidx2] = cr2 - ci3;
out[oidx2 + 1] = ci2 + cr3;
out[oidx3] = cr2 + ci3;
out[oidx3 + 1] = ci2 - cr3;
}
} else {
for (int k = 1; k <= l1; k++) {
int idx1 = in_off + (3 * k - 2) * ido;
int idx2 = out_off + (k - 1) * ido;
for (int i = 0; i < ido - 1; i += 2) {
int iidx1 = i + idx1;
int iidx2 = iidx1 + ido;
int iidx3 = iidx1 - ido;
float a1r = in[iidx1];
float a1i = in[iidx1 + 1];
float a2r = in[iidx2];
float a2i = in[iidx2 + 1];
float a3r = in[iidx3];
float a3i = in[iidx3 + 1];
tr2 = a1r + a2r;
cr2 = a3r + taur * tr2;
ti2 = a1i + a2i;
ci2 = a3i + taur * ti2;
cr3 = isign * taui * (a1r - a2r);
ci3 = isign * taui * (a1i - a2i);
dr2 = cr2 - ci3;
dr3 = cr2 + ci3;
di2 = ci2 + cr3;
di3 = ci2 - cr3;
int widx1 = i + iw1;
int widx2 = i + iw2;
float w1r = wtable[widx1];
float w1i = isign * wtable[widx1 + 1];
float w2r = wtable[widx2];
float w2i = isign * wtable[widx2 + 1];
int oidx1 = i + idx2;
int oidx2 = oidx1 + idxt;
int oidx3 = oidx2 + idxt;
out[oidx1] = a3r + tr2;
out[oidx1 + 1] = a3i + ti2;
out[oidx2] = w1r * dr2 - w1i * di2;
out[oidx2 + 1] = w1r * di2 + w1i * dr2;
out[oidx3] = w2r * dr3 - w2i * di3;
out[oidx3 + 1] = w2r * di3 + w2i * dr3;
}
}
}
}
/*----------------------------------------------------------------------
passf4: Complex FFT's forward/backward processing of factor 4;
isign is +1 for backward and -1 for forward transforms
----------------------------------------------------------------------
void passf4(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset, final int isign) {
float ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4;
int iw1, iw2, iw3;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
int idx0 = l1 * ido;
if (ido == 2) {
for (int k = 0; k < l1; k++) {
int idxt1 = k * ido;
int iidx1 = in_off + 4 * idxt1 + 1;
int iidx2 = iidx1 + ido;
int iidx3 = iidx2 + ido;
int iidx4 = iidx3 + ido;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
ti1 = i1r - i3r;
ti2 = i1r + i3r;
tr4 = i4r - i2r;
ti3 = i2r + i4r;
tr1 = i1i - i3i;
tr2 = i1i + i3i;
ti4 = i2i - i4i;
tr3 = i2i + i4i;
int oidx1 = out_off + idxt1;
int oidx2 = oidx1 + idx0;
int oidx3 = oidx2 + idx0;
int oidx4 = oidx3 + idx0;
out[oidx1] = tr2 + tr3;
out[oidx1 + 1] = ti2 + ti3;
out[oidx2] = tr1 + isign * tr4;
out[oidx2 + 1] = ti1 + isign * ti4;
out[oidx3] = tr2 - tr3;
out[oidx3 + 1] = ti2 - ti3;
out[oidx4] = tr1 - isign * tr4;
out[oidx4 + 1] = ti1 - isign * ti4;
}
} else {
for (int k = 0; k < l1; k++) {
int idx1 = k * ido;
int idx2 = in_off + 1 + 4 * idx1;
for (int i = 0; i < ido - 1; i += 2) {
int iidx1 = i + idx2;
int iidx2 = iidx1 + ido;
int iidx3 = iidx2 + ido;
int iidx4 = iidx3 + ido;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
ti1 = i1r - i3r;
ti2 = i1r + i3r;
ti3 = i2r + i4r;
tr4 = i4r - i2r;
tr1 = i1i - i3i;
tr2 = i1i + i3i;
ti4 = i2i - i4i;
tr3 = i2i + i4i;
cr3 = tr2 - tr3;
ci3 = ti2 - ti3;
cr2 = tr1 + isign * tr4;
cr4 = tr1 - isign * tr4;
ci2 = ti1 + isign * ti4;
ci4 = ti1 - isign * ti4;
int widx1 = i + iw1;
int widx2 = i + iw2;
int widx3 = i + iw3;
float w1r = wtable[widx1];
float w1i = isign * wtable[widx1 + 1];
float w2r = wtable[widx2];
float w2i = isign * wtable[widx2 + 1];
float w3r = wtable[widx3];
float w3i = isign * wtable[widx3 + 1];
int oidx1 = out_off + i + idx1;
int oidx2 = oidx1 + idx0;
int oidx3 = oidx2 + idx0;
int oidx4 = oidx3 + idx0;
out[oidx1] = tr2 + tr3;
out[oidx1 + 1] = ti2 + ti3;
out[oidx2] = w1r * cr2 - w1i * ci2;
out[oidx2 + 1] = w1r * ci2 + w1i * cr2;
out[oidx3] = w2r * cr3 - w2i * ci3;
out[oidx3 + 1] = w2r * ci3 + w2i * cr3;
out[oidx4] = w3r * cr4 - w3i * ci4;
out[oidx4 + 1] = w3r * ci4 + w3i * cr4;
}
}
}
}
/*----------------------------------------------------------------------
passf5: Complex FFT's forward/backward processing of factor 5;
isign is +1 for backward and -1 for forward transforms
----------------------------------------------------------------------
void passf5(final int ido, final int l1, final float[] in, final int in_off, final float[] out, final int out_off, final int offset, final int isign)
/* isign==-1 for forward transform and+1 for backward transform
{
final float tr11 = 0.309016994374947451262869435595348477f;
final float ti11 = 0.951056516295153531181938433292089030f;
final float tr12 = -0.809016994374947340240566973079694435f;
final float ti12 = 0.587785252292473248125759255344746634f;
float ci2, ci3, ci4, ci5, di3, di4, di5, di2, cr2, cr3, cr5, cr4, ti2, ti3, ti4, ti5, dr3, dr4, dr5, dr2, tr2, tr3, tr4, tr5;
int iw1, iw2, iw3, iw4;
iw1 = offset;
iw2 = iw1 + ido;
iw3 = iw2 + ido;
iw4 = iw3 + ido;
int idx0 = l1 * ido;
if (ido == 2) {
for (int k = 1; k <= l1; ++k) {
int iidx1 = in_off + (5 * k - 4) * ido + 1;
int iidx2 = iidx1 + ido;
int iidx3 = iidx1 - ido;
int iidx4 = iidx2 + ido;
int iidx5 = iidx4 + ido;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
ti5 = i1r - i5r;
ti2 = i1r + i5r;
ti4 = i2r - i4r;
ti3 = i2r + i4r;
tr5 = i1i - i5i;
tr2 = i1i + i5i;
tr4 = i2i - i4i;
tr3 = i2i + i4i;
cr2 = i3i + tr11 * tr2 + tr12 * tr3;
ci2 = i3r + tr11 * ti2 + tr12 * ti3;
cr3 = i3i + tr12 * tr2 + tr11 * tr3;
ci3 = i3r + tr12 * ti2 + tr11 * ti3;
cr5 = isign * (ti11 * tr5 + ti12 * tr4);
ci5 = isign * (ti11 * ti5 + ti12 * ti4);
cr4 = isign * (ti12 * tr5 - ti11 * tr4);
ci4 = isign * (ti12 * ti5 - ti11 * ti4);
int oidx1 = out_off + (k - 1) * ido;
int oidx2 = oidx1 + idx0;
int oidx3 = oidx2 + idx0;
int oidx4 = oidx3 + idx0;
int oidx5 = oidx4 + idx0;
out[oidx1] = i3i + tr2 + tr3;
out[oidx1 + 1] = i3r + ti2 + ti3;
out[oidx2] = cr2 - ci5;
out[oidx2 + 1] = ci2 + cr5;
out[oidx3] = cr3 - ci4;
out[oidx3 + 1] = ci3 + cr4;
out[oidx4] = cr3 + ci4;
out[oidx4 + 1] = ci3 - cr4;
out[oidx5] = cr2 + ci5;
out[oidx5 + 1] = ci2 - cr5;
}
} else {
for (int k = 1; k <= l1; k++) {
int idx1 = in_off + 1 + (k * 5 - 4) * ido;
int idx2 = out_off + (k - 1) * ido;
for (int i = 0; i < ido - 1; i += 2) {
int iidx1 = i + idx1;
int iidx2 = iidx1 + ido;
int iidx3 = iidx1 - ido;
int iidx4 = iidx2 + ido;
int iidx5 = iidx4 + ido;
float i1i = in[iidx1 - 1];
float i1r = in[iidx1];
float i2i = in[iidx2 - 1];
float i2r = in[iidx2];
float i3i = in[iidx3 - 1];
float i3r = in[iidx3];
float i4i = in[iidx4 - 1];
float i4r = in[iidx4];
float i5i = in[iidx5 - 1];
float i5r = in[iidx5];
ti5 = i1r - i5r;
ti2 = i1r + i5r;
ti4 = i2r - i4r;
ti3 = i2r + i4r;
tr5 = i1i - i5i;
tr2 = i1i + i5i;
tr4 = i2i - i4i;
tr3 = i2i + i4i;
cr2 = i3i + tr11 * tr2 + tr12 * tr3;
ci2 = i3r + tr11 * ti2 + tr12 * ti3;
cr3 = i3i + tr12 * tr2 + tr11 * tr3;
ci3 = i3r + tr12 * ti2 + tr11 * ti3;
cr5 = isign * (ti11 * tr5 + ti12 * tr4);
ci5 = isign * (ti11 * ti5 + ti12 * ti4);
cr4 = isign * (ti12 * tr5 - ti11 * tr4);
ci4 = isign * (ti12 * ti5 - ti11 * ti4);
dr3 = cr3 - ci4;
dr4 = cr3 + ci4;
di3 = ci3 + cr4;
di4 = ci3 - cr4;
dr5 = cr2 + ci5;
dr2 = cr2 - ci5;
di5 = ci2 - cr5;
di2 = ci2 + cr5;
int widx1 = i + iw1;
int widx2 = i + iw2;
int widx3 = i + iw3;
int widx4 = i + iw4;
float w1r = wtable[widx1];
float w1i = isign * wtable[widx1 + 1];
float w2r = wtable[widx2];
float w2i = isign * wtable[widx2 + 1];
float w3r = wtable[widx3];
float w3i = isign * wtable[widx3 + 1];
float w4r = wtable[widx4];
float w4i = isign * wtable[widx4 + 1];
int oidx1 = i + idx2;
int oidx2 = oidx1 + idx0;
int oidx3 = oidx2 + idx0;
int oidx4 = oidx3 + idx0;
int oidx5 = oidx4 + idx0;
out[oidx1] = i3i + tr2 + tr3;
out[oidx1 + 1] = i3r + ti2 + ti3;
out[oidx2] = w1r * dr2 - w1i * di2;
out[oidx2 + 1] = w1r * di2 + w1i * dr2;
out[oidx3] = w2r * dr3 - w2i * di3;
out[oidx3 + 1] = w2r * di3 + w2i * dr3;
out[oidx4] = w3r * dr4 - w3i * di4;
out[oidx4 + 1] = w3r * di4 + w3i * dr4;
out[oidx5] = w4r * dr5 - w4i * di5;
out[oidx5 + 1] = w4r * di5 + w4i * dr5;
}
}
}
}
/*----------------------------------------------------------------------
passfg: Complex FFT's forward/backward processing of general factor;
isign is +1 for backward and -1 for forward transforms
---------------------------------------------------------------------- | FloatFFT::passfg | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/FloatFFT.java | Apache-2.0 |
public TriangularWindow() {
} |
A Triangular window function.
@author Damien Di Fede
@author Corban Brook
@see <a
href="http://en.wikipedia.org/wiki/Window_function#Triangular_window_.28non-zero_end-points.29">The
Triangular Window</a>
public class TriangularWindow extends WindowFunction {
/** Constructs a Triangular window. | TriangularWindow::TriangularWindow | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/TriangularWindow.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/TriangularWindow.java | Apache-2.0 |
public GaussWindow(double alpha) {
if (alpha < 0.0 || alpha > 0.5) {
new IllegalArgumentException(
"Range for GaussWindow out of bounds. Value must be <= 0.5");
} else {
this.alpha = alpha;
}
} |
Constructs a Gauss window function.
@param alpha the alpha parameter for the window construction.
| GaussWindow::GaussWindow | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/GaussWindow.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/GaussWindow.java | Apache-2.0 |
public GaussWindow() {
this(0.25);
} |
Constructs a Gauss window function.
@param alpha the alpha parameter for the window construction.
public GaussWindow(double alpha) {
if (alpha < 0.0 || alpha > 0.5) {
new IllegalArgumentException(
"Range for GaussWindow out of bounds. Value must be <= 0.5");
} else {
this.alpha = alpha;
}
}
/** Constructs a Gauss window with a default alpha value of 0.25 | GaussWindow::GaussWindow | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/util/fft/GaussWindow.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/util/fft/GaussWindow.java | Apache-2.0 |
public WaveHeader() {
} |
Construct a WaveHeader, with all fields defaulting to zero.
| WaveHeader::WaveHeader | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | Apache-2.0 |
public WaveHeader(short format, short numChannels, int sampleRate, short bitsPerSample, int numBytes) {
mFormat = format;
mSampleRate = sampleRate;
mNumChannels = numChannels;
mBitsPerSample = bitsPerSample;
mNumBytes = numBytes;
} |
Construct a WaveHeader, with fields initialized.
@param format format of audio data,
one of {@link #FORMAT_PCM}, {@link #FORMAT_ULAW}, or {@link #FORMAT_ALAW}.
@param numChannels 1 for mono, 2 for stereo.
@param sampleRate typically 8000, 11025, 16000, 22050, or 44100 hz.
@param bitsPerSample usually 16 for PCM, 8 for ULAW or 8 for ALAW.
@param numBytes size of audio data after this header, in bytes.
| WaveHeader::WaveHeader | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | Apache-2.0 |
public short getFormat() {
return mFormat;
} |
Get the format field.
@return format field,
one of {@link #FORMAT_PCM}, {@link #FORMAT_ULAW}, or {@link #FORMAT_ALAW}.
| WaveHeader::getFormat | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | Apache-2.0 |
public WaveHeader setFormat(short format) {
mFormat = format;
return this;
} |
Set the format field.
@param format
one of {@link #FORMAT_PCM}, {@link #FORMAT_ULAW}, or {@link #FORMAT_ALAW}.
@return reference to this WaveHeader instance.
| WaveHeader::setFormat | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | Apache-2.0 |
public short getNumChannels() {
return mNumChannels;
} |
Get the number of channels.
@return number of channels, 1 for mono, 2 for stereo.
| WaveHeader::getNumChannels | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | Apache-2.0 |
public WaveHeader setNumChannels(short numChannels) {
mNumChannels = numChannels;
return this;
} |
Set the number of channels.
@param numChannels 1 for mono, 2 for stereo.
@return reference to this WaveHeader instance.
| WaveHeader::setNumChannels | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | Apache-2.0 |
public int getSampleRate() {
return mSampleRate;
} |
Get the sample rate.
@return sample rate, typically 8000, 11025, 16000, 22050, or 44100 hz.
| WaveHeader::getSampleRate | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | Apache-2.0 |
public WaveHeader setSampleRate(int sampleRate) {
mSampleRate = sampleRate;
return this;
} |
Set the sample rate.
@param sampleRate sample rate, typically 8000, 11025, 16000, 22050, or 44100 hz.
@return reference to this WaveHeader instance.
| WaveHeader::setSampleRate | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | Apache-2.0 |
public short getBitsPerSample() {
return mBitsPerSample;
} |
Get the number of bits per sample.
@return number of bits per sample,
usually 16 for PCM, 8 for ULAW or 8 for ALAW.
| WaveHeader::getBitsPerSample | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | Apache-2.0 |
public WaveHeader setBitsPerSample(short bitsPerSample) {
mBitsPerSample = bitsPerSample;
return this;
} |
Set the number of bits per sample.
@param bitsPerSample number of bits per sample,
usually 16 for PCM, 8 for ULAW or 8 for ALAW.
@return reference to this WaveHeader instance.
| WaveHeader::setBitsPerSample | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | Apache-2.0 |
public int getNumBytes() {
return mNumBytes;
} |
Get the size of audio data after this header, in bytes.
@return size of audio data after this header, in bytes.
| WaveHeader::getNumBytes | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | Apache-2.0 |
public WaveHeader setNumBytes(int numBytes) {
mNumBytes = numBytes;
return this;
} |
Set the size of audio data after this header, in bytes.
@param numBytes size of audio data after this header, in bytes.
@return reference to this WaveHeader instance.
| WaveHeader::setNumBytes | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | Apache-2.0 |
public int read(InputStream in) throws IOException {
/* RIFF header */
readId(in, "RIFF");
readId(in, "WAVE");
/* fmt chunk */
readId(in, "fmt ");
if (16 != readInt(in)) throw new IOException("fmt chunk length not 16");
mFormat = readShort(in);
mNumChannels = readShort(in);
mSampleRate = readInt(in);
int byteRate = readInt(in);
short blockAlign = readShort(in);
mBitsPerSample = readShort(in);
if (byteRate != mNumChannels * mSampleRate * mBitsPerSample / 8) {
throw new IOException("fmt.ByteRate field inconsistent");
}
if (blockAlign != mNumChannels * mBitsPerSample / 8) {
throw new IOException("fmt.BlockAlign field inconsistent");
}
/* data chunk */
readId(in, "data");
mNumBytes = readInt(in);
return HEADER_LENGTH;
} |
Read and initialize a WaveHeader.
@param in {@link java.io.InputStream} to read from.
@return number of bytes consumed.
@throws IOException
| WaveHeader::read | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | Apache-2.0 |
public int write(OutputStream out) throws IOException {
/* RIFF header */
writeId(out, "RIFF");
writeInt(out, 36 + mNumBytes);
writeId(out, "WAVE");
/* fmt chunk */
writeId(out, "fmt ");
writeInt(out, 16);
writeShort(out, mFormat);
writeShort(out, mNumChannels);
writeInt(out, mSampleRate);
writeInt(out, mNumChannels * mSampleRate * mBitsPerSample / 8);
writeShort(out, (short)(mNumChannels * mBitsPerSample / 8));
writeShort(out, mBitsPerSample);
/* data chunk */
writeId(out, "data");
writeInt(out, mNumBytes);
return HEADER_LENGTH;
} |
Write a WAVE file header.
@param out {@link java.io.OutputStream} to receive the header.
@return number of bytes written.
@throws IOException
| WaveHeader::write | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/writer/WaveHeader.java | Apache-2.0 |
public WriterProcessor(TarsosDSPAudioFormat audioFormat,RandomAccessFile output){
this.output=output;
this.audioFormat=audioFormat;
try {
output.write(new byte[HEADER_LENGTH]);
} catch (IOException e) {
e.printStackTrace();
}
} |
@param audioFormat which this processor is attached to
@param output randomaccessfile of the output file
| WriterProcessor::WriterProcessor | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/writer/WriterProcessor.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/writer/WriterProcessor.java | Apache-2.0 |
private Event newEvent(double time, int beatNum) {
return new Event(time,time, time, 56, 64, beatNum, 0, 1);
} |
Creates a new Event object representing an onset or beat.
@param time
The time of the beat in seconds
@param beatNum
The index of the beat or onset.
@return The Event object representing the beat or onset.
| BeatRootOnsetEventHandler::newEvent | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/BeatRootOnsetEventHandler.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/BeatRootOnsetEventHandler.java | Apache-2.0 |
public void trackBeats(OnsetHandler beatHandler){
AgentList agents = null;
// tempo not given; use tempo induction
agents = Induction.beatInduction(onsetList);
agents.beatTrack(onsetList, -1);
Agent best = agents.bestAgent();
if (best != null) {
best.fillBeats(-1.0);
EventList beats = best.events;
Iterator<Event> eventIterator = beats.iterator();
while(eventIterator.hasNext()){
Event beat = eventIterator.next();
double time = beat.keyDown;
beatHandler.handleOnset(time, -1);
}
} else {
System.err.println("No best agent");
}
} |
Guess the beats using the populated list of onsets.
@param beatHandler
Use this handler to get the time of the beats. The salience of
the beat is not calculated: -1 is returned.
| BeatRootOnsetEventHandler::trackBeats | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/BeatRootOnsetEventHandler.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/BeatRootOnsetEventHandler.java | Apache-2.0 |
public AgentList() {
this(null, null);
} | For the purpose of removing duplicate agents, the JND of phase.
* Not changed in the current version.
public static double thresholdBT = DEFAULT_BT;
/** Default constructor | AgentList::AgentList | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | Apache-2.0 |
public AgentList(Agent a, AgentList al) {
ag = a;
next = al;
if (next == null) {
if (ag != null)
next = new AgentList(); // insert null-terminator if it was forgotten
else {
count = 0;
thresholdBI = DEFAULT_BI;
thresholdBT = DEFAULT_BT;
}
}
} // constructor | Constructor for an AgentList: the Agent a is prepended to the list al.
@param a The Agent at the head of the list
@param al The tail of the list
| AgentList::AgentList | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | Apache-2.0 |
public void print() {
System.out.println("agentList.print: (size=" + count + ")");
for (AgentList ptr = this; ptr.ag != null; ptr = ptr.next)
ptr.ag.print(2);
System.out.println("End of agentList.print()");
} // print() | Constructor for an AgentList: the Agent a is prepended to the list al.
@param a The Agent at the head of the list
@param al The tail of the list
public AgentList(Agent a, AgentList al) {
ag = a;
next = al;
if (next == null) {
if (ag != null)
next = new AgentList(); // insert null-terminator if it was forgotten
else {
count = 0;
thresholdBI = DEFAULT_BI;
thresholdBT = DEFAULT_BT;
}
}
} // constructor
/** Deep print of AgentList for debugging | AgentList::print | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | Apache-2.0 |
public void add(Agent a) {
add(a, true);
} // add()/1 |
Inserts newAgent into the list in ascending order of beatInterval
@param a The new agent to add
| AgentList::add | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | Apache-2.0 |
public void add(Agent newAgent, boolean sort){
if (newAgent == null)
return;
AgentList ptr;
count++;
for (ptr = this; ptr.ag != null; ptr = ptr.next)
if (sort && (newAgent.beatInterval <= ptr.ag.beatInterval)) {
ptr.next = new AgentList(ptr.ag, ptr.next);
ptr.ag = newAgent;
return;
}
ptr.next = new AgentList();
ptr.ag = newAgent;
} // add()/2 | Appends newAgent to list (sort==false), or inserts newAgent into the list
in ascending order of beatInterval
@param newAgent The agent to be added to the list
@param sort Flag indicating whether the list is sorted or not
| AgentList::add | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | Apache-2.0 |
public void sort() {
boolean sorted = false;
while (!sorted) {
sorted = true;
for (AgentList ptr = this; ptr.ag != null; ptr = ptr.next) {
if ((ptr.next.ag != null) &&
(ptr.ag.beatInterval > ptr.next.ag.beatInterval)) {
Agent temp = ptr.ag;
ptr.ag = ptr.next.ag;
ptr.next.ag = temp;
sorted = false;
}
} // for
} // while
} // sort() | Sorts the AgentList by increasing beatInterval, using a bubble sort
* since it is assumed that the list is almost sorted. | AgentList::sort | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | Apache-2.0 |
public void remove(AgentList ptr) {
count--;
ptr.ag = ptr.next.ag; // null-terminated list always has next
ptr.next = ptr.next.next;
} // remove() | Removes the current item from the list.
The current item does not need to be the head of the whole list.
@param ptr Points to the Agent which is removed from the list
| AgentList::remove | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | Apache-2.0 |
protected void removeDuplicates() {
sort();
for (AgentList ptr = this; ptr.ag != null; ptr = ptr.next) {
if (ptr.ag.phaseScore < 0.0) // already flagged for deletion
continue;
for (AgentList ptr2 = ptr.next; ptr2.ag != null; ptr2 = ptr2.next) {
if (ptr2.ag.beatInterval - ptr.ag.beatInterval > thresholdBI)
break;
if (Math.abs(ptr.ag.beatTime - ptr2.ag.beatTime) > thresholdBT)
continue;
if (ptr.ag.phaseScore < ptr2.ag.phaseScore) {
ptr.ag.phaseScore = -1.0; // flag for deletion
if (ptr2.ag.topScoreTime < ptr.ag.topScoreTime)
ptr2.ag.topScoreTime = ptr.ag.topScoreTime;
break;
} else {
ptr2.ag.phaseScore = -1.0; // flag for deletion
if (ptr.ag.topScoreTime < ptr2.ag.topScoreTime)
ptr.ag.topScoreTime = ptr2.ag.topScoreTime;
}
}
}
for (AgentList ptr = this; ptr.ag != null; ) {
if (ptr.ag.phaseScore < 0.0) {
remove(ptr);
} else
ptr = ptr.next;
}
} // removeDuplicates() | Removes Agents from the list which are duplicates of other Agents.
A duplicate is defined by the tempo and phase thresholds
thresholdBI and thresholdBT respectively.
| AgentList::removeDuplicates | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | Apache-2.0 |
public void beatTrack(EventList el) {
beatTrack(el, -1.0);
} // beatTrack()/1 | Perform beat tracking on a list of events (onsets).
@param el The list of onsets (or events or peaks) to beat track
| AgentList::beatTrack | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | Apache-2.0 |
public void beatTrack(EventList el, double stop) {
ListIterator<Event> ptr = el.listIterator();
boolean phaseGiven = (ag != null) &&
(ag.beatTime >= 0); // if given for one, assume given for others
while (ptr.hasNext()) {
Event ev = ptr.next();
if ((stop > 0) && (ev.keyDown > stop))
break;
boolean created = phaseGiven;
double prevBeatInterval = -1.0;
for (AgentList ap = this; ap.ag != null; ap = ap.next) {
Agent currentAgent = ap.ag;
if (currentAgent.beatInterval != prevBeatInterval) {
if ((prevBeatInterval>=0) && !created && (ev.keyDown<5.0)) {
// Create new agent with different phase
Agent newAgent = new Agent(prevBeatInterval);
newAgent.considerAsBeat(ev, this);
add(newAgent);
}
prevBeatInterval = currentAgent.beatInterval;
created = phaseGiven;
}
if (currentAgent.considerAsBeat(ev, this))
created = true;
if (currentAgent != ap.ag) // new one been inserted, skip it
ap = ap.next;
} // loop for each agent
removeDuplicates();
} // loop for each event
} // beatTrack() | Perform beat tracking on a list of events (onsets).
@param el The list of onsets (or events or peaks) to beat track.
@param stop Do not find beats after <code>stop</code> seconds.
| AgentList::beatTrack | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | Apache-2.0 |
public Agent bestAgent() {
double best = -1.0;
Agent bestAg = null;
for (AgentList ap = this; ap.ag != null; ap = ap.next) {
double startTime = ap.ag.events.l.getFirst().keyDown;
double conf = (ap.ag.phaseScore + ap.ag.tempoScore) /
(useAverageSalience? (double)ap.ag.beatCount: 1.0);
if (conf > best) {
bestAg = ap.ag;
best = conf;
}
if (debug) {
ap.ag.print(0);
System.out.printf(" +%5.3f Av-salience = %3.1f\n",
startTime, conf);
}
}
if (debug) {
if (bestAg != null) {
System.out.print("Best ");
bestAg.print(0);
System.out.printf(" Av-salience = %5.1f\n", best);
// bestAg.events.print();
} else
System.out.println("No surviving agent - beat tracking failed");
}
return bestAg;
} // bestAgent() | Finds the Agent with the highest score in the list.
@return The Agent with the highest score
| AgentList::bestAgent | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/AgentList.java | Apache-2.0 |
public Agent(double ibi) {
init(ibi);
} // constructor | Constructor: the work is performed by init()
@param ibi The beat period (inter-beat interval) of the Agent's tempo hypothesis.
| Agent::Agent | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | Apache-2.0 |
public Agent(Agent clone) {
idNumber = idCounter++;
phaseScore = clone.phaseScore;
tempoScore = clone.tempoScore;
topScoreTime = clone.topScoreTime;
beatCount = clone.beatCount;
beatInterval = clone.beatInterval;
initialBeatInterval = clone.initialBeatInterval;
beatTime = clone.beatTime;
events = new EventList(clone.events);
postMargin = clone.postMargin;
preMargin = clone.preMargin;
} // copy constructor | Copy constructor.
* @param clone The Agent to duplicate. | Agent::Agent | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | Apache-2.0 |
protected void init(double ibi) {
innerMargin = INNER_MARGIN;
correctionFactor = DEFAULT_CORRECTION_FACTOR;
expiryTime = DEFAULT_EXPIRY_TIME;
decayFactor = 0;
beatInterval = ibi;
initialBeatInterval = ibi;
postMargin = ibi * POST_MARGIN_FACTOR;
preMargin = ibi * PRE_MARGIN_FACTOR;
idNumber = idCounter++;
phaseScore = 0.0;
tempoScore = 0.0;
topScoreTime = 0.0;
beatCount = 0;
beatTime = -1.0;
events = new EventList();
} // init() | Initialise all the fields of this Agent.
@param ibi The initial tempo hypothesis of the Agent.
| Agent::init | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | Apache-2.0 |
public void print() {
print(100);
} // print()/0 | Initialise all the fields of this Agent.
@param ibi The initial tempo hypothesis of the Agent.
protected void init(double ibi) {
innerMargin = INNER_MARGIN;
correctionFactor = DEFAULT_CORRECTION_FACTOR;
expiryTime = DEFAULT_EXPIRY_TIME;
decayFactor = 0;
beatInterval = ibi;
initialBeatInterval = ibi;
postMargin = ibi * POST_MARGIN_FACTOR;
preMargin = ibi * PRE_MARGIN_FACTOR;
idNumber = idCounter++;
phaseScore = 0.0;
tempoScore = 0.0;
topScoreTime = 0.0;
beatCount = 0;
beatTime = -1.0;
events = new EventList();
} // init()
/** Output debugging information about this Agent, at the default (highest) level of detail. | Agent::print | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | Apache-2.0 |
public void print(int level) {
System.out.printf("\tAg#%4d: %5.3f", idNumber, beatInterval);
if (level >= 1) {
System.out.printf(
" Beat#%3d Time=%7.3f Score=%4.2f:P%4.2f:%3.1f",
beatCount, beatTime, tempoScore, phaseScore,
topScoreTime);
}
if (level >= 2)
System.out.println();
if (level >= 3)
events.print();
} // print() | Output debugging information about this Agent.
@param level The level of detail in debugging
| Agent::print | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | Apache-2.0 |
protected void accept(Event e, double err, int beats) {
beatTime = e.keyDown;
events.add(e);
if (Math.abs(initialBeatInterval - beatInterval -
err / correctionFactor) < MAX_CHANGE * initialBeatInterval)
beatInterval += err / correctionFactor;// Adjust tempo
beatCount += beats;
double conFactor = 1.0 - CONF_FACTOR * err /
(err>0? postMargin: -preMargin);
if (decayFactor > 0) {
double memFactor = 1. - 1. / threshold(beatCount,1,decayFactor);
phaseScore = memFactor * phaseScore +
(1.0 - memFactor) * conFactor * e.salience;
} else
phaseScore += conFactor * e.salience;
if (debug) {
print(1);
System.out.printf(" Err=" + (err<0?"":"+") + "%5.3f" +
(Math.abs(err) > innerMargin ? '*':' ') + "%5.3f\n",
err, conFactor);
}
} // accept() | Accept a new Event as a beat time, and update the state of the Agent accordingly.
@param e The Event which is accepted as being on the beat.
@param err The difference between the predicted and actual beat times.
@param beats The number of beats since the last beat that matched an Event.
| Agent::accept | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | Apache-2.0 |
public boolean considerAsBeat(Event e, AgentList a) {
double err;
if (beatTime < 0) { // first event
accept(e, 0, 1);
return true;
} else { // subsequent events
if (e.keyDown - events.l.getLast().keyDown > expiryTime) {
phaseScore = -1.0; // flag agent to be deleted
return false;
}
double beats = Math.round((e.keyDown - beatTime) / beatInterval);
err = e.keyDown - beatTime - beats * beatInterval;
if ((beats > 0) && (-preMargin <= err) && (err <= postMargin)) {
if (Math.abs(err) > innerMargin) // Create new agent that skips this
a.add(new Agent(this)); // event (avoids large phase jump)
accept(e, err, (int)beats);
return true;
}
}
return false;
} // considerAsBeat() | The given Event is tested for a possible beat time. The following situations can occur:
1) The Agent has no beats yet; the Event is accepted as the first beat.
2) The Event is beyond expiryTime seconds after the Agent's last 'confirming' beat; the Agent is terminated.
3) The Event is within the innerMargin of the beat prediction; it is accepted as a beat.
4) The Event is within the outerMargin's of the beat prediction; it is accepted as a beat by this Agent,
and a new Agent is created which doesn't accept it as a beat.
5) The Event is ignored because it is outside the windows around the Agent's predicted beat time.
@param e The Event to be tested
@param a The list of all agents, which is updated if a new agent is created.
@return Indicate whether the given Event was accepted as a beat by this Agent.
| Agent::considerAsBeat | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | Apache-2.0 |
protected void fillBeats() {
fillBeats(-1.0);
} // fillBeats()/0 | The given Event is tested for a possible beat time. The following situations can occur:
1) The Agent has no beats yet; the Event is accepted as the first beat.
2) The Event is beyond expiryTime seconds after the Agent's last 'confirming' beat; the Agent is terminated.
3) The Event is within the innerMargin of the beat prediction; it is accepted as a beat.
4) The Event is within the outerMargin's of the beat prediction; it is accepted as a beat by this Agent,
and a new Agent is created which doesn't accept it as a beat.
5) The Event is ignored because it is outside the windows around the Agent's predicted beat time.
@param e The Event to be tested
@param a The list of all agents, which is updated if a new agent is created.
@return Indicate whether the given Event was accepted as a beat by this Agent.
public boolean considerAsBeat(Event e, AgentList a) {
double err;
if (beatTime < 0) { // first event
accept(e, 0, 1);
return true;
} else { // subsequent events
if (e.keyDown - events.l.getLast().keyDown > expiryTime) {
phaseScore = -1.0; // flag agent to be deleted
return false;
}
double beats = Math.round((e.keyDown - beatTime) / beatInterval);
err = e.keyDown - beatTime - beats * beatInterval;
if ((beats > 0) && (-preMargin <= err) && (err <= postMargin)) {
if (Math.abs(err) > innerMargin) // Create new agent that skips this
a.add(new Agent(this)); // event (avoids large phase jump)
accept(e, err, (int)beats);
return true;
}
}
return false;
} // considerAsBeat()
/** Interpolates missing beats in the Agent's beat track, starting from the beginning of the piece. | Agent::fillBeats | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | Apache-2.0 |
public void fillBeats(double start) {
double prevBeat = 0, nextBeat, currentInterval, beats;
ListIterator<Event> list = events.listIterator();
if (list.hasNext()) {
prevBeat = list.next().keyDown;
// alt. to fill from 0:
// prevBeat = Math.mod(list.next().keyDown, beatInterval);
list.previous();
}
for ( ; list.hasNext(); list.next()) {
nextBeat = list.next().keyDown;
list.previous();
beats = Math.round((nextBeat - prevBeat) / beatInterval - 0.01); //prefer slow
currentInterval = (nextBeat - prevBeat) / beats;
for ( ; (nextBeat > start) && (beats > 1.5); beats--) {
prevBeat += currentInterval;
if (debug)
System.out.printf("Insert beat at: %8.3f (n=%1.0f)\n",
prevBeat, beats - 1.0);
list.add(newBeat(prevBeat, 0)); // more than once OK??
}
prevBeat = nextBeat;
}
} // fillBeats() | Interpolates missing beats in the Agent's beat track.
@param start Ignore beats earlier than this start time
| Agent::fillBeats | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | Apache-2.0 |
private Event newBeat(double time, int beatNum) {
return new Event(time,time, time, 56, 64, beatNum, 0, 1);
} // newBeat() | Creates a new Event object representing a beat.
@param time The time of the beat in seconds
@param beatNum The index of the beat
@return The Event object representing the beat
| Agent::newBeat | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | Apache-2.0 |
public void showTracking(EventList allEvents) {
showTracking(allEvents, 1.0);
} // showTracking()/1 | Show detailed debugging output describing the beat tracking behaviour of this agent.
Calls showTracking()/1 with a default metrical level of 1.
@param allEvents An EventList of all onsets
| Agent::showTracking | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | Apache-2.0 |
public void showTracking(EventList allEvents, double level) {
int count = 1, gapCount;
double prevBeat, nextBeat, gap;
ListIterator<Event> beats = events.listIterator(); // point to 1st beat
ListIterator<Event> all = allEvents.listIterator(); // point to 1st event
if (!beats.hasNext()) {
System.err.println("No beats found");
return;
}
prevBeat = events.l.getFirst().keyDown;
// prevBeat = fmod(beats.next().keyDown, beatInterval);
System.out.print("Beat (IBI) BeatTime Other Events");
boolean first = true;
while (all.hasNext()) { // print each real event
Event currentEvent = all.next();
Event currentBeat = null;
while (beats.hasNext()) { // if event was chosen as beat
currentBeat = beats.next();
if (currentBeat.keyDown > currentEvent.keyDown + Induction.clusterWidth)
break;
gap = currentBeat.keyDown - prevBeat;
gapCount = (int) Math.round(gap / beatInterval);
for (int j = 1; j < gapCount; j++) { //empty beat(s) before event
nextBeat = prevBeat + gap / gapCount;
System.out.printf("\n%4d (%5.3f) [%7.3f ]",
count++, nextBeat - prevBeat, nextBeat);
prevBeat = nextBeat;
}
System.out.printf("\n%4d (%5.3f) ",
count++, currentEvent.keyDown - prevBeat);
prevBeat = currentBeat.keyDown;
currentBeat = null;
first = false;
}
if ((currentBeat != null) && (currentBeat.keyDown > currentEvent.keyDown)) {
gap = currentBeat.keyDown - prevBeat;
gapCount = (int) Math.round(gap / beatInterval);
for (int j = 1; j < gapCount; j++) { //empty beat(s) before event
nextBeat = prevBeat + gap / gapCount;
if (nextBeat >= currentEvent.keyDown)
break;
System.out.printf("\n%4d (%5.3f) [%7.3f ]",
count++, nextBeat - prevBeat, nextBeat);
prevBeat = nextBeat;
}
first = false;
}
if (first) // for correct formatting of any initial (pre-beat) events
System.out.print("\n ");
System.out.printf("%8.3f%c ", currentEvent.keyDown,
Math.abs(currentEvent.scoreBeat / level -
Math.round(currentEvent.scoreBeat / level)) < 0.001?
'*': ' ');
first = false;
}
System.out.println();
} // showTracking() | Show detailed debugging output describing the beat tracking behaviour of this agent.
@param allEvents An EventList of all onsets
@param level The metrical level of beat tracking relative to the notated beat (used to count beats)
| Agent::showTracking | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/Agent.java | Apache-2.0 |
public static AgentList beatInduction(EventList events) {
int i, j, b, bestCount;
boolean submult;
int intervals = 0; // number of interval clusters
int[] bestn = new int[topN];// count of high-scoring clusters
double ratio, err;
int degree;
int maxClusterCount = (int) Math.ceil((maxIOI - minIOI) / clusterWidth);
double[] clusterMean = new double[maxClusterCount];
int[] clusterSize = new int[maxClusterCount];
int[] clusterScore = new int[maxClusterCount];
ListIterator<Event> ptr1, ptr2;
Event e1,e2;
ptr1 = events.listIterator();
while (ptr1.hasNext()) {
e1 = ptr1.next();
ptr2 = events.listIterator();
e2 = ptr2.next();
while (e2 != e1)
e2 = ptr2.next();
while (ptr2.hasNext()) {
e2 = ptr2.next();
double ioi = e2.keyDown - e1.keyDown;
if (ioi < minIOI) // skip short intervals
continue;
if (ioi > maxIOI) // ioi too long
break;
for (b = 0; b < intervals; b++) // assign to nearest cluster
if (Math.abs(clusterMean[b] - ioi) < clusterWidth) {
if ((b < intervals - 1) && (
Math.abs(clusterMean[b+1] - ioi) <
Math.abs(clusterMean[b] - ioi)))
b++; // next cluster is closer
clusterMean[b] = (clusterMean[b] * clusterSize[b] +ioi)/
(clusterSize[b] + 1);
clusterSize[b]++;
break;
}
if (b == intervals) { // no suitable cluster; create new one
if (intervals == maxClusterCount) {
System.err.println("Warning: Too many clusters");
continue; // ignore this IOI
}
intervals++;
for ( ; (b>0) && (clusterMean[b-1] > ioi); b--) {
clusterMean[b] = clusterMean[b-1];
clusterSize[b] = clusterSize[b-1];
}
clusterMean[b] = ioi;
clusterSize[b] = 1;
}
}
}
if (debug) { // output IOI histogram in Matlab format
System.out.println("Inter-onset interval histogram:\n" +
"StartMatlabCode\n" +
"ioi = [");
for (b = 0; b < intervals; b++)
System.out.printf("%4d %7.3f %7d\n",
b, clusterMean[b], clusterSize[b]);
System.out.println("]; ioiclusters(ioi, name);\nEndMatlabCode\n");
}
for (b = 0; b < intervals; b++) // merge similar intervals
// TODO: they are now in order, so don't need the 2nd loop
// TODO: check BOTH sides before averaging or upper gps don't work
for (i = b+1; i < intervals; i++)
if (Math.abs(clusterMean[b] - clusterMean[i]) < clusterWidth) {
clusterMean[b] = (clusterMean[b] * clusterSize[b] +
clusterMean[i] * clusterSize[i]) /
(clusterSize[b] + clusterSize[i]);
clusterSize[b] = clusterSize[b] + clusterSize[i];
--intervals;
for (j = i+1; j <= intervals; j++) {
clusterMean[j-1] = clusterMean[j];
clusterSize[j-1] = clusterSize[j];
}
}
if (intervals == 0)
return new AgentList();
for (b = 0; b < intervals; b++)
clusterScore[b] = 10 * clusterSize[b];
bestn[0] = 0;
bestCount = 1;
for (b = 0; b < intervals; b++)
for (i = 0; i <= bestCount; i++)
if ((i < topN) && ((i == bestCount) ||
(clusterScore[b] > clusterScore[bestn[i]]))){
if (bestCount < topN)
bestCount++;
for (j = bestCount - 1; j > i; j--)
bestn[j] = bestn[j-1];
bestn[i] = b;
break;
}
if (debug) {
System.out.println("Best " + bestCount + " clusters (before):");
for (b = 0; b < bestCount; b++)
System.out.printf("%5.3f : %5d\n", clusterMean[bestn[b]],
clusterScore[bestn[b]]);
}
for (b = 0; b < intervals; b++) // score intervals
for (i = b+1; i < intervals; i++) {
ratio = clusterMean[b] / clusterMean[i];
submult = ratio < 1;
if (submult)
degree = (int) Math.round(1/ratio);
else
degree = (int) Math.round(ratio);
if ((degree >= 2) && (degree <= 8)) {
if (submult)
err = Math.abs(clusterMean[b]*degree - clusterMean[i]);
else
err = Math.abs(clusterMean[b] - clusterMean[i]*degree);
if (err < (submult? clusterWidth : clusterWidth * degree)) {
if (degree >= 5)
degree = 1;
else
degree = 6 - degree;
clusterScore[b] += degree * clusterSize[i];
clusterScore[i] += degree * clusterSize[b];
}
}
}
if (debug) {
System.out.println("Best " + bestCount + " clusters (after):");
for (b = 0; (b < bestCount); b++)
System.out.printf("%5.3f : %5d\n", clusterMean[bestn[b]],
clusterScore[bestn[b]]);
}
if (debug) {
System.out.println("Inter-onset interval histogram 2:");
for (b = 0; b < intervals; b++)
System.out.printf("%3d: %5.3f : %3d (score: %5d)\n",
b, clusterMean[b], clusterSize[b], clusterScore[b]);
}
AgentList a = new AgentList();
for (int index = 0; index < bestCount; index++) {
b = bestn[index];
// Adjust it, using the size of super- and sub-intervals
double newSum = clusterMean[b] * clusterScore[b];
//int newCount = clusterSize[b];
int newWeight = clusterScore[b];
for (i = 0; i < intervals; i++) {
if (i == b)
continue;
ratio = clusterMean[b] / clusterMean[i];
if (ratio < 1) {
degree = (int) Math.round(1 / ratio);
if ((degree >= 2) && (degree <= 8)) {
err = Math.abs(clusterMean[b]*degree - clusterMean[i]);
if (err < clusterWidth) {
newSum += clusterMean[i] / degree * clusterScore[i];
//newCount += clusterSize[i];
newWeight += clusterScore[i];
}
}
} else {
degree = (int) Math.round(ratio);
if ((degree >= 2) && (degree <= 8)) {
err = Math.abs(clusterMean[b] - degree*clusterMean[i]);
if (err < clusterWidth * degree) {
newSum += clusterMean[i] * degree * clusterScore[i];
//newCount += clusterSize[i];
newWeight += clusterScore[i];
}
}
}
}
double beat = newSum / newWeight;
// Scale within range ... hope the grouping isn't ternary :(
while (beat < minIBI) // Maximum speed
beat *= 2.0;
while (beat > maxIBI) // Minimum speed
beat /= 2.0;
if (beat >= minIBI) {
a.add(new Agent(beat));
if (debug)
System.out.printf(" %5.3f", beat);
}
}
if (debug)
System.out.println(" IBI");
return a;
} // beatInduction() | Performs tempo induction (see JNMR 2001 paper by Simon Dixon for details).
@param events The onsets (or other events) from which the tempo is induced
@return A list of beat tracking agents, where each is initialised with one
of the top tempo hypotheses but no beats
| Induction::beatInduction | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/Induction.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/Induction.java | Apache-2.0 |
protected static int top(int low) {
return low + 25; // low/10;
} // top() | For variable cluster widths in newInduction().
@param low The lowest IOI allowed in the cluster
@return The highest IOI allowed in the cluster
| Induction::top | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/Induction.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/Induction.java | Apache-2.0 |
public static void newInduction(EventList events) {
final int MAX_MS = 2500;
int[] count = new int[MAX_MS];
for (int i=0; i < MAX_MS; i++)
count[i] = 0;
ListIterator<Event> ptr1, ptr2;
Event e1,e2;
ptr1 = events.listIterator();
while (ptr1.hasNext()) {
e1 = ptr1.next();
ptr2 = events.listIterator();
e2 = ptr2.next();
while (e2 != e1)
e2 = ptr2.next();
while (ptr2.hasNext()) {
e2 = ptr2.next();
int diff = (int) Math.round((e1.keyDown - e2.keyDown) * 1000);
if (diff < MAX_MS)
count[diff]++;
else
break;
}
}
int clnum;
final int MAX_CL = 10;
int[] cluster = new int[MAX_CL];
int[] csize = new int[MAX_CL];
for (clnum = 0; clnum < MAX_CL; clnum++) {
int sum = 0;
int max = 0;
int maxp = 0;
int hi = 70;
int lo = hi;
while (hi < MAX_MS) {
if (hi >= top(lo))
sum -= count[lo++];
else {
sum += count[hi++];
if (sum > max) {
max = sum;
maxp = lo;
}
}
}
if (max == 0)
break;
hi = top(maxp);
if (hi > MAX_MS)
hi = MAX_MS;
int cnt = sum = 0;
for (lo = maxp; lo < hi; lo++) {
sum += lo * count[lo];
cnt += count[lo];
count[lo] = 0;
}
if (cnt != max)
System.err.println("Rounding error in newInduction");
cluster[clnum] = sum / cnt;
csize[clnum] = cnt;
System.out.printf(" %5.3f", sum / 1000.0 / cnt);
//System.out.println("Cluster " + (clnum+1) ": " + (sum/cnt) +
// "ms (" + cnt + " intervals)");
}
System.out.println(" IBI");
// System.out.println("END OF NEW_INDUCTION");
} // newInduction() | An alternative (incomplete) tempo induction method (not used).
Uses integer (millisecond) resolution.
@param events The events on which tempo induction is performed
| Induction::newInduction | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/Induction.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/Induction.java | Apache-2.0 |
public static int findPeaks(double[] data, int[] peaks, int width) {
int peakCount = 0;
int maxp = 0;
int mid = 0;
int end = data.length;
while (mid < end) {
int i = mid - width;
if (i < 0)
i = 0;
int stop = mid + width + 1;
if (stop > data.length)
stop = data.length;
maxp = i;
for (i++; i < stop; i++)
if (data[i] > data[maxp])
maxp = i;
if (maxp == mid) {
int j;
for (j = peakCount; j > 0; j--) {
if (data[maxp] <= data[peaks[j-1]])
break;
else if (j < peaks.length)
peaks[j] = peaks[j-1];
}
if (j != peaks.length)
peaks[j] = maxp;
if (peakCount != peaks.length)
peakCount++;
}
mid++;
}
return peakCount;
} // findPeaks() |
General peak picking method for finding n local maxima in an array
@param data input data
@param peaks list of peak indexes
@param width minimum distance between peaks
@return The number of peaks found
| Peaks::findPeaks | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/Peaks.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/Peaks.java | Apache-2.0 |
public static LinkedList<Integer> findPeaks(double[] data, int width,
double threshold) {
return findPeaks(data, width, threshold, 0, false);
} // findPeaks() | General peak picking method for finding local maxima in an array
@param data input data
@param width minimum distance between peaks
@param threshold minimum value of peaks
@return list of peak indexes
| Peaks::findPeaks | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/Peaks.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/Peaks.java | Apache-2.0 |
public static LinkedList<Integer> findPeaks(double[] data, int width,
double threshold, double decayRate, boolean isRelative) {
LinkedList<Integer> peaks = new LinkedList<Integer>();
int maxp = 0;
int mid = 0;
int end = data.length;
double av = data[0];
while (mid < end) {
av = decayRate * av + (1 - decayRate) * data[mid];
if (av < data[mid])
av = data[mid];
int i = mid - width;
if (i < 0)
i = 0;
int stop = mid + width + 1;
if (stop > data.length)
stop = data.length;
maxp = i;
for (i++; i < stop; i++)
if (data[i] > data[maxp])
maxp = i;
if (maxp == mid) {
if (overThreshold(data, maxp, width, threshold, isRelative,av)){
if (debug)
System.out.println(" peak");
peaks.add(Integer.valueOf(maxp));
} else if (debug)
System.out.println();
}
mid++;
}
return peaks;
} // findPeaks() | General peak picking method for finding local maxima in an array
@param data input data
@param width minimum distance between peaks
@param threshold minimum value of peaks
@param decayRate how quickly previous peaks are forgotten
@param isRelative minimum value of peaks is relative to local average
@return list of peak indexes
| Peaks::findPeaks | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/Peaks.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/Peaks.java | Apache-2.0 |
public static void getSlope(double[] data, double hop, int n,
double[] slope) {
int i = 0, j = 0;
double t;
double sx = 0, sxx = 0, sy = 0, sxy = 0;
for ( ; i < n; i++) {
t = i * hop;
sx += t;
sxx += t * t;
sy += data[i];
sxy += t * data[i];
}
double delta = n * sxx - sx * sx;
for ( ; j < n / 2; j++)
slope[j] = (n * sxy - sx * sy) / delta;
for ( ; j < data.length - (n + 1) / 2; j++, i++) {
slope[j] = (n * sxy - sx * sy) / delta;
sy += data[i] - data[i - n];
sxy += hop * (n * data[i] - sy);
}
for ( ; j < data.length; j++)
slope[j] = (n * sxy - sx * sy) / delta;
} // getSlope() | Uses an n-point linear regression to estimate the slope of data.
@param data input data
@param hop spacing of data points
@param n length of linear regression
@param slope output data
| Peaks::getSlope | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/Peaks.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/Peaks.java | Apache-2.0 |
public void print() {
for (Iterator<Event> i = l.iterator(); i.hasNext(); )
i.next().print(flags);
} // print() |
A score/match/midi file is represented as an EventList object,
which contains pointers to the head and tail links, and some
class-wide parameters. Parameters are class-wide, as it is
assumed that the Worm has only one input file at a time.
public class EventList {
public LinkedList<Event> l;
private static boolean timingCorrection = false;
private static double timingDisplacement = 0;
private static final int clockUnits = 480;
private static final int clockRate = 500000;
private static final double metricalLevel = 0;
private static final double UNKNOWN = Double.NaN;
private static final boolean noMelody = false;
private static final boolean onlyMelody = false;
private static final Flags flags = new Flags();
public EventList() {
l = new LinkedList<Event>();
} // constructor
public EventList(EventList e) {
this();
ListIterator<Event> it = e.listIterator();
while (it.hasNext())
add(it.next());
} // constructor
public EventList(Event[] e) {
this();
for (int i=0; i < e.length; i++)
add(e[i]);
} // constructor
public void add(Event e) {
l.add(e);
} // add()
public void add(EventList ev) {
l.addAll(ev.l);
} // add()
public void insert(Event newEvent, boolean uniqueTimes) {
ListIterator<Event> li = l.listIterator();
while (li.hasNext()) {
int sgn = newEvent.compareTo(li.next());
if (sgn < 0) {
li.previous();
break;
} else if (uniqueTimes && (sgn == 0)) {
li.remove();
break;
}
}
li.add(newEvent);
} // insert()
public ListIterator<Event> listIterator() {
return l.listIterator();
} // listIterator()
public Iterator<Event> iterator() {
return l.iterator();
} // iterator()
public int size() {
return l.size();
} // size()
public Event[] toArray() {
return toArray(0);
} // toArray()
public double[] toOnsetArray() {
double[] d = new double[l.size()];
int i = 0;
for (Iterator<Event> it = l.iterator(); it.hasNext(); i++)
d[i] = it.next().keyDown;
return d;
} // toOnsetArray()
public Event[] toArray(int match) {
int count = 0;
for (Event e : l)
if ((match == 0) || (e.midiCommand == match))
count++;
Event[] a = new Event[count];
int i = 0;
for (Event e : l)
if ((match == 0) || (e.midiCommand == match))
a[i++] = e;
return a;
} // toArray()
public void writeBinary(String fileName) {
try {
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream(fileName));
oos.writeObject(this);
oos.close();
} catch (IOException e) {
System.err.println(e);
}
} // writeBinary()
public static EventList readBinary(String fileName) {
try {
ObjectInputStream ois = new ObjectInputStream(
new FileInputStream(fileName));
EventList e = (EventList) ois.readObject();
ois.close();
return e;
} catch (IOException e) {
System.err.println(e);
return null;
} catch (ClassNotFoundException e) {
System.err.println(e);
return null;
}
} // readBinary()
/*
public void writeMIDI(String fileName) {
writeMIDI(fileName, null);
} // writeMIDI()
public void writeMIDI(String fileName, EventList pedal) {
try {
MidiSystem.write(toMIDI(pedal), 1, new File(fileName));
} catch (Exception e) {
System.err.println("Error: Unable to write MIDI file " + fileName);
e.printStackTrace();
}
} // writeMIDI()
public Sequence toMIDI(EventList pedal) throws InvalidMidiDataException {
final int midiTempo = 1000000;
Sequence s = new Sequence(Sequence.PPQ, 1000);
Track[] tr = new Track[16];
tr[0] = s.createTrack();
MetaMessage mm = new MetaMessage();
byte[] b = new byte[3];
b[0] = (byte)((midiTempo >> 16) & 0xFF);
b[1] = (byte)((midiTempo >> 8) & 0xFF);
b[2] = (byte)(midiTempo & 0xFF);
mm.setMessage(0x51, b, 3);
tr[0].add(new MidiEvent(mm, 0L));
for (Event e : l) { // from match or beatTrack file
if (e.midiCommand == 0) // skip beatTrack file
break;
if (tr[e.midiTrack] == null)
tr[e.midiTrack] = s.createTrack();
//switch (e.midiCommand)
//case ShortMessage.NOTE_ON:
//case ShortMessage.POLY_PRESSURE:
//case ShortMessage.CONTROL_CHANGE:
//case ShortMessage.PROGRAM_CHANGE:
//case ShortMessage.CHANNEL_PRESSURE:
//case ShortMessage.PITCH_BEND:
ShortMessage sm = new ShortMessage();
sm.setMessage(e.midiCommand, e.midiChannel,
e.midiPitch, e.midiVelocity);
tr[e.midiTrack].add(new MidiEvent(sm,
(long)Math.round(1000 * e.keyDown)));
if (e.midiCommand == ShortMessage.NOTE_ON) {
sm = new ShortMessage();
sm.setMessage(ShortMessage.NOTE_OFF, e.midiChannel, e.midiPitch, 0);
tr[e.midiTrack].add(new MidiEvent(sm, (long)Math.round(1000 * e.keyUp)));
}
}
if (pedal != null) { // from MIDI file
// if (t.size() > 0) // otherwise beatTrack files leave an empty trk
// t = s.createTrack();
for (Event e : pedal.l) {
if (tr[e.midiTrack] == null)
tr[e.midiTrack] = s.createTrack();
ShortMessage sm = new ShortMessage();
sm.setMessage(e.midiCommand, e.midiChannel,
e.midiPitch, e.midiVelocity);
tr[e.midiTrack].add(new MidiEvent(sm,
(long)Math.round(1000 * e.keyDown)));
if (e.midiCommand == ShortMessage.NOTE_ON) {
sm = new ShortMessage();
sm.setMessage(ShortMessage.NOTE_OFF, e.midiChannel,
e.midiPitch,e.midiVelocity);
tr[e.midiTrack].add(new MidiEvent(sm,
(long)Math.round(1000 * e.keyUp)));
}
//catch (InvalidMidiDataException exception) {}
}
}
return s;
} // toMIDI()
public static EventList readMidiFile(String fileName) {
return readMidiFile(fileName, 0);
} // readMidiFile()
public static EventList readMidiFile(String fileName, int skipTrackFlag) {
EventList list = new EventList();
Sequence s;
try {
s = MidiSystem.getSequence(new File(fileName));
} catch (Exception e) {
e.printStackTrace();
return list;
}
double midiTempo = 500000;
double tempoFactor = midiTempo / s.getResolution() / 1000000.0;
// System.err.println(tempoFactor);
Event[][] noteOns = new Event[128][16];
Track[] tracks = s.getTracks();
for (int t = 0; t < tracks.length; t++, skipTrackFlag >>= 1) {
if ((skipTrackFlag & 1) == 1)
continue;
for (int e = 0; e < tracks[t].size(); e++) {
MidiEvent me = tracks[t].get(e);
MidiMessage mm = me.getMessage();
double time = me.getTick() * tempoFactor;
byte[] mesg = mm.getMessage();
int channel = mesg[0] & 0x0F;
int command = mesg[0] & 0xF0;
if (command == ShortMessage.NOTE_ON) {
int pitch = mesg[1] & 0x7F;
int velocity = mesg[2] & 0x7F;
if (noteOns[pitch][channel] != null) {
if (velocity == 0) { // NOTE_OFF in disguise :(
noteOns[pitch][channel].keyUp = time;
noteOns[pitch][channel].pedalUp = time;
noteOns[pitch][channel] = null;
} else
System.err.println("Double note on: n=" + pitch +
" c=" + channel +
" t1=" + noteOns[pitch][channel] +
" t2=" + time);
} else {
Event n = new Event(time, 0, 0, pitch, velocity, -1, -1,
0, ShortMessage.NOTE_ON, channel, t);
noteOns[pitch][channel] = n;
list.add(n);
}
} else if (command == ShortMessage.NOTE_OFF) {
int pitch = mesg[1] & 0x7F;
noteOns[pitch][channel].keyUp = time;
noteOns[pitch][channel].pedalUp = time;
noteOns[pitch][channel] = null;
} else if (command == 0xF0) {
if ((channel == 0x0F) && (mesg[1] == 0x51)) {
midiTempo = (mesg[5] & 0xFF) |
((mesg[4] & 0xFF) << 8) |
((mesg[3] & 0xFF) << 16);
tempoFactor = midiTempo / s.getResolution() / 1000000.0;
// System.err.println("Info: Tempo change: " + midiTempo +
// " tf=" + tempoFactor);
}
} else if (mesg.length > 3) {
System.err.println("midi message too long: " + mesg.length);
System.err.println("\tFirst byte: " + mesg[0]);
} else {
int b0 = mesg[0] & 0xFF;
int b1 = -1;
int b2 = -1;
if (mesg.length > 1)
b1 = mesg[1] & 0xFF;
if (mesg.length > 2)
b2 = mesg[2] & 0xFF;
list.add(new Event(time, time, -1, b1, b2, -1, -1, 0,
b0 & 0xF0, b0 & 0x0F, t));
}
}
}
for (int pitch = 0; pitch < 128; pitch++)
for (int channel = 0; channel < 16; channel++)
if (noteOns[pitch][channel] != null)
System.err.println("Missing note off: n=" +
noteOns[pitch][channel].midiPitch + " t=" +
noteOns[pitch][channel].keyDown);
return list;
} // readMidiFile()
| EventList::print | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/beatroot/EventList.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/beatroot/EventList.java | Apache-2.0 |
public OptimizedGranulator(float sampleRate,int bufferSize) {
grains = new Grain[50];
for(int i = 0 ; i < grains.length ; i++){
grains[i] = new Grain();
}
audioBuffer = new float[4800*2];//max 0.2s
audioBufferWatermark = 0;
pitchFactor = 1.0f;
grainInterval = 40.0f;
grainSize = 100.0f;
grainRandomness = 0.1f;
window = new be.tarsos.dsp.util.fft.CosineWindow().generateCurve(512);
outputBuffer = new float[bufferSize];
audioSampleLength = 1000.0f/sampleRate;
} |
Instantiates a new GranularSamplePlayer.
@param sampleRate the sample rate.
@param bufferSize the size of an output buffer.
| OptimizedGranulator::OptimizedGranulator | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/granulator/OptimizedGranulator.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/granulator/OptimizedGranulator.java | Apache-2.0 |
private void firstGrain() {
if(firstGrain) {
Grain g = grains[0];
g.position = position;
g.age = grainSize / 4f;
g.grainSize = grainSize;
firstGrain = false;
timeSinceLastGrain = grainInterval / 2f;
}
} |
Instantiates a new GranularSamplePlayer.
@param sampleRate the sample rate.
@param bufferSize the size of an output buffer.
public OptimizedGranulator(float sampleRate,int bufferSize) {
grains = new Grain[50];
for(int i = 0 ; i < grains.length ; i++){
grains[i] = new Grain();
}
audioBuffer = new float[4800*2];//max 0.2s
audioBufferWatermark = 0;
pitchFactor = 1.0f;
grainInterval = 40.0f;
grainSize = 100.0f;
grainRandomness = 0.1f;
window = new be.tarsos.dsp.util.fft.CosineWindow().generateCurve(512);
outputBuffer = new float[bufferSize];
audioSampleLength = 1000.0f/sampleRate;
}
public void start() {
timeSinceLastGrain = 0;
}
/** Flag to indicate special case for the first grain.
private boolean firstGrain = true;
/** Special case method for playing first grain. | OptimizedGranulator::firstGrain | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/granulator/OptimizedGranulator.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/granulator/OptimizedGranulator.java | Apache-2.0 |
public double getFrameLinear(double posInMS) {
double result = 0.0;
double sampleNumber = msToSamples(posInMS);
int sampleNumberFloor = (int) Math.floor(sampleNumber);
if (sampleNumberFloor > 0 && sampleNumberFloor < audioBufferWatermark) {
double sampleNumberFraction = sampleNumber - sampleNumberFloor;
if (sampleNumberFloor == audioBufferWatermark - 1) {
result = audioBuffer[sampleNumberFloor];
} else {
// linear interpolation
double current = audioBuffer[sampleNumberFloor];
double next = audioBuffer[sampleNumberFloor];
result = (float) ((1 - sampleNumberFraction) * current + sampleNumberFraction * next);
}
}
return result;
} |
Retrieves a frame of audio using linear interpolation. If the frame is
not in the sample range then zeros are returned.
@param posInMS
The frame to read -- can be fractional (e.g., 4.4).
@return
The framedata to fill.
| OptimizedGranulator::getFrameLinear | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/granulator/OptimizedGranulator.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/granulator/OptimizedGranulator.java | Apache-2.0 |
public float getFrameNoInterp(double posInMS) {
double frame = msToSamples(posInMS);
int frame_floor = (int) Math.floor(frame);
//int diff = audioBufferWatermark - frame_floor;
//if( diff < 4800 || diff > )
return audioBuffer[frame_floor];
} |
Retrieves a frame of audio using no interpolation. If the frame is not in
the sample range then zeros are returned.
@param posInMS
The frame to read -- will take the last frame before this one.
| OptimizedGranulator::getFrameNoInterp | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/granulator/OptimizedGranulator.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/granulator/OptimizedGranulator.java | Apache-2.0 |
public float getFrameCubic(double posInMS) {
float frame = (float) msToSamples(posInMS);
float result = 0.0f;
float a0, a1, a2, a3, mu2;
float ym1, y0, y1, y2;
int realCurrentSample = (int) Math.floor(frame);
float fractionOffset = frame - realCurrentSample;
if (realCurrentSample >= 0 && realCurrentSample < (audioBufferWatermark - 1)) {
realCurrentSample--;
if (realCurrentSample < 0) {
ym1 = audioBuffer[0];
realCurrentSample = 0;
} else {
ym1 = audioBuffer[realCurrentSample++];
}
y0 = audioBuffer[realCurrentSample++];
if (realCurrentSample >= audioBufferWatermark) {
y1 = audioBuffer[audioBufferWatermark-1]; // ??
} else {
y1 = audioBuffer[realCurrentSample++];
}
if (realCurrentSample >= audioBufferWatermark) {
y2 = audioBuffer[audioBufferWatermark-1];
} else {
y2 = audioBuffer[realCurrentSample++];
}
mu2 = fractionOffset * fractionOffset;
a0 = y2 - y1 - ym1 + y0;
a1 = ym1 - y0 - a0;
a2 = y1 - ym1;
a3 = y0;
result = a0 * fractionOffset * mu2 + a1 * mu2 + a2 * fractionOffset + a3;
}
return result;
} |
Retrieves a frame of audio using cubic interpolation. If the frame is not
in the sample range then zeros are returned.
@param posInMS
The frame to read -- can be fractional (e.g., 4.4).
| OptimizedGranulator::getFrameCubic | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/granulator/OptimizedGranulator.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/granulator/OptimizedGranulator.java | Apache-2.0 |
public float getValueFraction(float fraction) {
float posInBuf = fraction * window.length;
if(fraction >= 1.0f){
posInBuf -= 1.0f;
}
int lowerIndex = (int) posInBuf;
float offset = posInBuf - lowerIndex;
int upperIndex = (lowerIndex + 1) % window.length;
return (1 - offset) * window[lowerIndex] + offset * window[upperIndex];
} |
Returns the value of the buffer at the given fraction along its length (0 = start, 1 = end). Uses linear interpolation.
@param fraction the point along the buffer to inspect.
@return the value at that point.
| OptimizedGranulator::getValueFraction | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/granulator/OptimizedGranulator.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/granulator/OptimizedGranulator.java | Apache-2.0 |
private void calculateNextGrainPosition(Grain g) {
int direction = timeStretchFactor >= 0 ? 1 : -1; //this is a bit odd in the case when controlling grain from positionEnvelope
g.age += audioSampleLength;
g.position += direction * audioSampleLength * pitchFactor;
} |
Calculate next position for the given Grain.
@param g the Grain.
| OptimizedGranulator::calculateNextGrainPosition | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/granulator/OptimizedGranulator.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/granulator/OptimizedGranulator.java | Apache-2.0 |
public void setPosition(float position) {
this.position = position * 1000;
} |
@param position in seconds
| OptimizedGranulator::setPosition | java | ZTFtrue/MonsterMusic | app/src/main/java/be/tarsos/dsp/granulator/OptimizedGranulator.java | https://github.com/ZTFtrue/MonsterMusic/blob/master/app/src/main/java/be/tarsos/dsp/granulator/OptimizedGranulator.java | Apache-2.0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.