public static Complex[] RealFastFourierTransform(double[] src, double amplitude = 1.0)
{
int n4 = 1 << (Mt.Log2Int(src.Length) - 2);
int n = n4 * 4, n2 = n4 * 2, n3 = n4 * 3;
int n2mask = n2 - 1;
Complex[] Data = new Complex[n2 + 1];
for (int i = n2; --i >= 0;)
{
Data[i] = new Complex(src[i * 2], src[i * 2 + 1]);
}
Complex[] Dst = FastFourierTransform_(Data, true);
TriangularTable Triangle = TriangularTable.Get(n);
for (int i = n4; i >= 0; --i)
{
int j = n2 - i;
Complex g1 = Dst[i];
Complex g2 = Complex.Conjugate(Dst[j & n2mask]);
Complex h1 = (g1 + g2);
Complex h2 = (g1 - g2) * Triangle.Complex(n3 - i);
Data[i] = (h1 + h2);
Data[j] = Complex.Conjugate(h1 - h2);
}
LetMul(Data, amplitude / 2);
return(Data);
}
//-------------------------------------------------------------------------------------
#region Parts
//-------------------------------------------------------------
//0埋め
private static double[] zeroInserting(double[] data)
{
int size = data.Length;
int fixed_size = 1 << Mt.Log2Int(size) + 1;
if (fixed_size > size)
{
double[] outdata = new double[fixed_size];
for (int i = 0; i < size; i++)
{
outdata[i] = data[i];
}
return(outdata);
}
else
{
return(data);
}
}
static Complex[] FastFourierTransform_(Complex[] src, bool sw)
{
int l = Mt.Log2Int(src.Length);
int n = 1 << l;
Complex[] Data = new Complex[n];
for (int j = -(n >> 1), i = 0; i < n; i++)
{
int k = n;
while ((k >>= 1) <= j)
{
j -= k;
}
j += k;
Data[i] = src[j];
}
int sign = sw ? -1 : 1;
TriangularTable Triangle = TriangularTable.Get(n);
for (int m = 0; m < l; m++)
{
int step = 1 << m;
int rotw = sign * (1 << (l - 1 - m));
for (int k = 0; k < step; k++)
{
Complex u = Triangle.Complex(rotw * k); // (2 * Math.PI / n) * rotw * k
for (int i = k; i < n; i += step * 2)
{
Complex t = Data[i + step] * u;
Data[i + step] = Data[i] - t;
Data[i] += t;
}
}
}
return(Data);
}
//-------------------------------------------------------------------------------------
//STFT（短時間フーリエ変換）
public static Complex[,] STFT(double[] source_data, int window_size)
{
Complex[,] output;
int source_length = source_data.Length; //入力データ長
int T_step; //時間ステップ数
int F_step; //周波数ステップ数
int fft_start_point = 0; //fftをするスタート点
double window_power = powerOfwindow(window_size); //窓関数のパワー WN
T_step = (int)((source_length - window_size) / window_power) - 1;
int n4 = 1 << (Mt.Log2Int(window_size) - 2);
int n = n4 * 4, n2 = n4 * 2;
F_step = n2 + 1;
output = new Complex[F_step, T_step];
for (int t = 0; t < T_step; t++)
{
double[] data = new double[window_size];
fft_start_point = (int)window_power * t;
for (int i = 0; i < window_size; i++)
{
data[i] = source_data[fft_start_point + i];
}
data = windowing(data);
Complex[] fft = Nm.RealFastFourierTransform(data);
for (int f = 0; f < F_step; f++)
{
output[f, t] = fft[f];
}
}
return(output);
}
public static double[] RealFastFourierTransform(Complex[] src, double amplitude = 1.0)
{
int n4 = 1 << (Mt.Log2Int(src.Length) - 1);
int n = n4 * 4, n2 = n4 * 2, n3 = n4 * 3;
int n2mask = n2 - 1;
Complex[] Data = new Complex[n2];
TriangularTable Triangle = TriangularTable.Get(n);
for (int i = n4; i >= 0; --i)
{
int j = n2 - i;
Complex g1 = src[i];
Complex g2 = Complex.Conjugate(src[j]);
Complex h1 = (g1 + g2);
Complex h2 = (g1 - g2) * Triangle.Complex(n4 + i);
Data[i] = (h1 + h2);
Data[j & n2mask] = Complex.Conjugate(h1 - h2);
}
Data = FastFourierTransform_(Data, false);
LetMul(Data, amplitude / n);
double[] Dst = New.Array(n, i => (i & 1) == 0 ? Data[i / 2].Real : Data[i / 2].Imaginary);
return(Dst);
}
