Benutzung von GNU Octave FFT-Funktionen

Question

Ich bin mit Oktave fft Funktionen zu spielen, und ich kann wirklich nicht herausfinden, wie sie ihre Ausgabe skalieren: Ich verwende den folgenden (sehr kurz) Code, um eine Funktion zu nähern:

function y = f(x) 
    y = x .^ 2; 
endfunction; 

X=[-4096:4095]/64; 
Y = f(X); 
# plot(X, Y); 

F = fft(Y); 
S = [0:2047]/2048; 

function points = approximate(input, count) 
    size = size(input)(2); 
    fourier = [fft(input)(1:count) zeros(1, size-count)]; 
    points = ifft(fourier); 
endfunction; 

Y = f(X); plot(X, Y, X, approximate(Y, 10)); 

Grundsätzlich, was es tut, ist eine Funktion zu nehmen, berechnen Sie das Bild eines Intervalls, fft-it, dann ein paar Oberwellen, und dann das Ergebnis. Aber ich bekomme ein Diagramm, das vertikal komprimiert ist (die vertikale Skala der Ausgabe ist falsch). Irgendwelche Ideen?

Answer 1

Sie machen es wahrscheinlich falsch. Sie entfernen alle "negativen" Frequenzen in Ihrem Code. Sie sollten sowohl positive als auch negative niedrige Frequenzen behalten. Hier ist ein Code in Python und das Ergebnis. Die Handlung hat die richtige Skala.

alt text http://files.droplr.com/files/35740123/XUl90.fft.png

Der Code:

from __future__ import division 

from scipy.signal import fft, ifft 
import numpy as np 

def approximate(signal, cutoff): 
    fourier = fft(signal) 
    size = len(signal) 
    # remove all frequencies except ground + offset positive, and offset negative: 
    fourier[1+cutoff:-cutoff] = 0 
    return ifft(fourier) 

def quad(x): 
    return x**2 

from pylab import plot 

X = np.arange(-4096,4096)/64 
Y = quad(X) 

plot(X,Y) 
plot(X,approximate(Y,3)) 

Answer 2

Sie werfen die zweite Hälfte der Transformation aus. Die Transformation ist hermitesch symmetrisch für reellwertige Eingaben und Sie müssen diese Zeilen behalten. Versuchen Sie folgendes:

function points = approximate(inp, count) 
    fourier = fft(inp); 
    fourier((count+1):(length(fourier)-count+1)) = 0; 
    points = real(ifft(fourier)); %# max(imag(ifft(fourier))) should be around eps(real(...)) 
endfunction; 

Die inverse Transformation wird unweigerlich einige winzige Imaginärteil haben aufgrund numerischer Berechnungsfehler, daher der real Extraktion.

Beachten Sie, dass input und size sind Schlüsselwörter in Octave; Sie mit Ihren eigenen Variablen zu überlisten, ist ein guter Weg, um wirklich seltsame Fehler auf die Straße zu bringen!