Great question! Let's break this down clearly since FFTW's r2c/c2r pair relies heavily on Hermitian symmetry to save computation and memory. When you modify the full spectrum B' and break that symmetry, you can't just feed a random half-spectrum into c2r and get valid results—here's how to fix this properly:

FFTW's c2r transform requires its input to be the compact, Hermitian-symmetric half-spectrum exactly matching what r2c outputs. Since your modified B' no longer has this symmetry, we need to first repair the symmetry, then extract the correct half-size input for c2r.

Step 1: Force Hermitian Symmetry on Your Full Spectrum #

The key property here is that only Hermitian-symmetric spectra produce real-valued inverse FFT results. So we'll create a corrected, symmetric full spectrum B_hermitian from your modified B' using these rules (assuming 0-based indexing, M rows, N columns, N even):

• For columns l = 0 or l = N/2 (these are their own symmetric counterparts), keep the value from B' directly: B_hermitian[k][l] = B'[k][l]
• For columns 0 < l < N/2, take the average of B'[k][l] and the complex conjugate of its symmetric counterpart B'[(M - k) % M][(N - l) % N]:
  B_hermitian[k][l] = 0.5 * (B'[k][l] + conj(B'[(M - k) % M][(N - l) % N]))
• Set the symmetric position ( (M - k) % M, (N - l) % N ) to the complex conjugate of B_hermitian[k][l] to enforce symmetry.

This ensures B_hermitian strictly follows the Hermitian rules required for a real-valued inverse transform.

Step 2: Extract the Compact Half-Spectrum #

From B_hermitian, pull the first N/2 + 1 columns to get B_half (size M × (N/2 + 1)). This is exactly the format c2r expects—same as the output of your original r2c transform.

Step 3: Run the c2r Inverse Transform #

Feed B_half into FFTW's c2r transform, and you'll get your real-valued output matrix. Don't forget to normalize the result by dividing by M*N—FFTW's r2c/c2r pairs don't apply normalization by default.

Alternative: Full Complex Inverse FFT + Take Real Part #

If you don't want to mess with reconstructing the symmetric spectrum, you can skip the above steps and run a full c2c inverse FFT on B', then take the real part of the resulting complex matrix. This works because taking the real part effectively enforces the Hermitian symmetry post-transform. The tradeoff is that this is less efficient than c2r, since it doesn't leverage symmetry to reduce computation.

Quick Pseudocode Example (C-style with FFTW3) #

// Assume B_prime is your modified full complex spectrum (M x N)
fftw_complex *B_hermitian = fftw_alloc_complex(M * N);

for (int k = 0; k < M; k++) {
    for (int l = 0; l < N; l++) {
        int k_sym = (M - k) % M;
        int l_sym = (N - l) % N;
        
        if (l <= N/2) {
            if (l == 0 || l == N/2) {
                // Symmetric point is itself, keep original value
                B_hermitian[k*N + l][0] = B_prime[k*N + l][0];
                B_hermitian[k*N + l][1] = B_prime[k*N + l][1];
            } else {
                // Average with conjugate of symmetric point
                double re = 0.5 * (B_prime[k*N + l][0] + B_prime[k_sym*N + l_sym][0]);
                double im = 0.5 * (B_prime[k*N + l][1] - B_prime[k_sym*N + l_sym][1]);
                B_hermitian[k*N + l][0] = re;
                B_hermitian[k*N + l][1] = im;
            }
            // Set symmetric point to conjugate
            B_hermitian[k_sym*N + l_sym][0] = B_hermitian[k*N + l][0];
            B_hermitian[k_sym*N + l_sym][1] = -B_hermitian[k*N + l][1];
        }
    }
}

// Extract half-spectrum for c2r
fftw_complex *B_half = fftw_alloc_complex(M * (N/2 + 1));
for (int k = 0; k < M; k++) {
    for (int l = 0; l <= N/2; l++) {
        B_half[k*(N/2+1) + l][0] = B_hermitian[k*N + l][0];
        B_half[k*(N/2+1) + l][1] = B_hermitian[k*N + l][1];
    }
}

// Execute c2r transform
double *A_prime = fftw_alloc_real(M * N);
fftw_plan p = fftw_plan_dft_c2r_2d(M, N, B_half, A_prime, FFTW_ESTIMATE);
fftw_execute(p);

// Normalize (critical!)
for (int i = 0; i < M*N; i++) {
    A_prime[i] /= (M * N);
}

// Cleanup
fftw_destroy_plan(p);
fftw_free(B_hermitian);
fftw_free(B_half);
fftw_free(A_prime);

Key Notes #

• Odd N Adjustment: If N is odd, r2c outputs (N+1)/2 columns. Adjust the symmetry rules so l_sym = N - l for l < (N+1)/2.
• Normalization: Always remember to divide by M*N—FFTW leaves normalization up to you to keep transforms fast.

内容的提问来源于stack exchange，提问作者Brani