/// <summary>
/// Forward Weyl-Heisenberg transform.
/// </summary>
/// <param name="A">Array</param>
/// <returns>Array</returns>
public Complex32[] Forward(Complex32[] A)
{
float[] g0 = WeylHeisenbergTransform.GetPacket(this.window, A.Length);
ZakTransform zakTransform = new ZakTransform(m);
return(FastWeylHeisenbergTransform.WHT(A, zakTransform.Forward(g0), m));
}
/// <summary>
/// Backward Weyl-Heisenberg transform.
/// </summary>
/// <param name="B">Array</param>
/// <returns>Array</returns>
public Complex32[] Backward(Complex32[] B)
{
int N = B.Length;
Complex32[,] U = WeylHeisenbergTransform.Matrix(this.window, N, this.m, true);
Complex32[] A = Matrice.Dot(B, U);
return(A);
}
/// <summary>
/// Forward Weyl-Heisenberg transform.
/// </summary>
/// <param name="A">Array</param>
/// <returns>Array</returns>
public Complex32[] Forward(Complex32[] A)
{
int N = A.Length;
Complex32[,] U = WeylHeisenbergTransform.Matrix(this.window, N, this.m, true);
Complex32[] B = Matrice.Dot(A, U.Hermitian());
return(B);
}
/// <summary>
/// Returns the complex Weyl-Heisenberg basis matrix.
/// <remarks>
/// Matrix dimension[N, N], where N = M * L.
/// </remarks>
/// </summary>
/// <param name="g0">Function</param>
/// <param name="M">Number of frequency shifts</param>
/// <param name="orthogonalize">Orthogonalized matrix or not</param>
/// <returns>Matrix</returns>
public static Complex32[,] Matrix(float[] g0, int M, bool orthogonalize = true)
{
if (orthogonalize)
{
ZakTransform zakTransform = new ZakTransform(M);
return(WeylHeisenbergTransform.Matrix(zakTransform.Forward(g0), M));
}
return(WeylHeisenbergTransform.Matrix(g0, M));
}
/// <summary>
/// Backward Weyl-Heisenberg transform.
/// </summary>
/// <param name="B">Matrix</param>
/// <returns>Matrix</returns>
public Complex32[,] Backward(Complex32[,] B)
{
int N = B.GetLength(0), M = B.GetLength(1);
Complex32[,] U = WeylHeisenbergTransform.Matrix(this.window, N, this.m, true);
Complex32[,] V = WeylHeisenbergTransform.Matrix(this.window, M, this.m, true);
Complex32[,] A;
if (direction == Direction.Both)
{
A = U.Dot(B).Dot(V.Hermitian());
}
else if (direction == Direction.Vertical)
{
A = U.Dot(B);
}
else
{
A = B.Dot(V.Hermitian());
}
return(A);
}
/// <summary>
/// Forward Weyl-Heisenberg transform.
/// </summary>
/// <param name="A">Matrix</param>
/// <returns>Matrix</returns>
public Complex32[,] Forward(Complex32[,] A)
{
int N = A.GetLength(0), M = A.GetLength(1);
Complex32[,] U = WeylHeisenbergTransform.Matrix(this.window, N, this.m, true);
Complex32[,] V = WeylHeisenbergTransform.Matrix(this.window, M, this.m, true);
Complex32[,] B;
if (direction == Direction.Both)
{
B = U.Hermitian().Dot(A).Dot(V);
}
else if (direction == Direction.Vertical)
{
B = U.Hermitian().Dot(A);
}
else
{
B = A.Dot(V);
}
return(B);
}
/// <summary>
/// Returns a vector of window function values.
/// </summary>
/// <param name="window">Windows function</param>
/// <param name="length">Number of samples</param>
/// <returns>Array</returns>
public static float[] GetPacket(IWindow window, int length)
{
// exeption by length
if (window.FrameSize > length)
{
return(WeylHeisenbergTransform.nSymmetry(window, length));
}
// params for approximation
float[] w = WeylHeisenbergTransform.nSymmetry(window, (int)window.FrameSize);
int n = w.Length;
float min = Math.Min(w[0], w[n - 1]);
float[] g = new float[length];
int i, j = (length - n) / 2;
int k = Math.Min(length - 2 * j, n);
int z = j + k;
// do job for intervals
for (i = 0; i < j; i++)
{
g[i] = min;
}
for (i = j; i < z; i++)
{
g[i] = w[i - j];
}
for (i = z; i < length; i++)
{
g[i] = min;
}
return(g);
}
/// <summary>
/// Returns the complex Weyl-Heisenberg basis matrix.
/// <remarks>
/// Matrix dimension[N, N], where N = M * L.
/// </remarks>
/// </summary>
/// <param name="window">Windows function</param>
/// <param name="N">Number of samples</param>
/// <param name="M">Number of frequency shifts</param>
/// <param name="orthogonalize">Orthogonalized matrix or not</param>
/// <returns>Matrix</returns>
public static Complex32[,] Matrix(IWindow window, int N, int M, bool orthogonalize = true)
{
return(WeylHeisenbergTransform.Matrix(WeylHeisenbergTransform.GetPacket(window, N), M, orthogonalize));
}
/// <summary>
/// Backward Weyl-Heisenberg transform.
/// </summary>
/// <param name="B">Matrix</param>
/// <returns>Matrix</returns>
public Complex32[,] Backward(Complex32[,] B)
{
Complex32[,] A = (Complex32[, ])B.Clone();
int N = B.GetLength(0);
int M = B.GetLength(1);
ZakTransform zakTransform = new ZakTransform(m);
float[] g0 = zakTransform.Forward(WeylHeisenbergTransform.GetPacket(this.window, N));
float[] g1 = zakTransform.Forward(WeylHeisenbergTransform.GetPacket(this.window, M));
if (direction == Direction.Both)
{
Parallel.For(0, M, j =>
{
Complex32[] col = new Complex32[N];
int i;
for (i = 0; i < N; i++)
{
col[i] = A[i, j];
}
col = IWHT(col, g0, m);
for (i = 0; i < N; i++)
{
A[i, j] = col[i];
}
});
Parallel.For(0, N, i =>
{
Complex32[] row = new Complex32[M];
int j;
for (j = 0; j < M; j++)
{
row[j] = A[i, j];
}
row = IWHT(row, g1, m);
for (j = 0; j < M; j++)
{
A[i, j] = row[j];
}
});
}
else if (direction == Direction.Vertical)
{
Parallel.For(0, M, j =>
{
Complex32[] col = new Complex32[N];
int i;
for (i = 0; i < N; i++)
{
col[i] = A[i, j];
}
col = IWHT(col, g0, m);
for (i = 0; i < N; i++)
{
A[i, j] = col[i];
}
});
}
else
{
Parallel.For(0, N, i =>
{
Complex32[] row = new Complex32[M];
int j;
for (j = 0; j < M; j++)
{
row[j] = A[i, j];
}
row = IWHT(row, g1, m);
for (j = 0; j < M; j++)
{
A[i, j] = row[j];
}
});
}
return(A);
}
