VF_filterVD_filterVE_filter
VCF_filterVCD_filterVCE_filter
FunktionFrequenz-Filterung
Syntax C/C++#include <VFstd.h>
void VF_filter(fVector Y, fVector X, fVector Flt, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::filter( const vector<T>& X, const vector<T>& Flt );
Pascal/Delphiuses VFstd;
procedure VF_filter( Y, X, Flt:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_filter(fVector d_Y, fVector d_X, fVector d_Flt, ui size );
void VFcu_filter(fVector h_Y, fVector h_X, fVector h_Flt, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_filter( d_Y, d_X, d_Flt:fVector; size:UIntSize ): IntBool;
procedure VFcu_filter( h_Y, h_X, h_Flt:fVector; size:UIntSize );
BeschreibungDas Frequenzfilter Flt wird auf den Vektor X angewendet. Intern wird hierzu eine Fourier-Transformation durchgeführt, die Transformierte mit Flt multipliziert und das Ergebnis wieder zurücktransformiert.

Komplexe Versionen: X, Y und der Filter Flt sind komplexe Vektoren.
Reelle Versionen: X und Y sind reell. Flt muss in dem bei VF_FFT beschriebenen gepackten komplexen Format vorliegen, das man automatisch durch Erzeugung des Filters mittels VF_FFT,   VF_convolve oder VF_deconvolve erhält.

Für rein reelle, analytisch bekannte Filterfunktionen konstruiere man den Filter, indem man ihn zunächst für einen reellen Vektor von size/2+1 Elementen berechnet und diesen reellen Vektor anschließen in Flt kopiert, wie in dem folgenden Beispiel (fNyquist = 0.5 / Abtast-Intervall; die gewünschte Grenzwinkelfrequenz ist fGrenz):
 

Beispiel C/C++:float Coeffs[3] = {1.0, 1.4142135, 1.0};
fVector Flt = VF_vector0( size );
fVector RealFlt = VF_vector( size/2+1 );
fVector Freq = VF_vector( size/2+1 );
VF_ramp( Freq, size/2+1, 0, (fNyquist / fGrenz) / (size/2) );
    /* normierte Frequenzen von 0 bis fNyquist / fGrenz */
VF_poly( RealFlt, Freq, size/2+1, Coeffs, 2 );
VF_inv( RealFlt, RealFlt, size/2+1 );
    /* Übertragungsfunktion aus Koeffizienten dieses Filters 2. Ordnung berechnen */
VF_RetoC( (cfVector)Flt, RealFlt, size/2 );
    /* Imaginärteile bleiben 0 */
Flt[1] = RealFlt[ size/2 ]; /* Übertragungsfunktion bei der Nyquist-Frequenz */
VF_filter( Y, X, Flt, size ); /* Anwendung des gerade konstruierten Filters auf X */

 
Dasselbe Beispiel für Pascal/Delphi:const Coeffs: array[0..2] of Single = (1.0, 1.4142135, 1.0);
var Flt, RealFlt, Freq: fVector;
    size_2: UIntSize;
begin
  ...
  size_2 := size div 2;
  Flt := VF_vector0( size );
  RealFlt := VF_vector( size_2+1 );
  Freq := VF_vector( size_2+1 );
  VF_ramp( Freq, size_2+1, 0, (fNyquist / fGrenz) / (size_2) );
      (* normierte Frequenzen von 0 bis fNyquist / fGrenz *)
  VF_poly( RealFlt, Freq, size_2+1, @Coeffs, 2 );
  VF_inv( RealFlt, RealFlt, size_2+1 );
      (* Übertragungsfunktion aus Koeffizienten dieses Filters 2. Ordnung berechnen *)
  VF_RetoC( cfVector(Flt), RealFlt, size_2 );
      (* Imaginärteile bleiben 0 *)
  VF_Pelement( Flt, 1 )^ := VF_element( RealFlt, size_2 );
      (* Übertragungsfunktion bei der Nyquist-Frequenz *)
  
VF_filter( Y, X, Flt, size ); (* Anwendung des gerade konstruierten Filters auf X *)
end;

Für nicht-periodisches X besteht die Gefahr von Rand-Effekten. Man sollte X in die Mitte eines doppelt so großen Vektors kopieren, so dass an beiden Enden genügend Nullen für die erforderliche Isolation sorgen. VF_filter ist dann auf den so erhaltenen größeren Vektor anzuwenden (siehe VF_convolve).

FehlerbehandlungWenn size nicht eine Potenz von 2 ist, meldet sich VF_FFT (worauf VF_filter basiert) mit der Fehlermeldung "Size must be integer power of 2." und bricht das Programm ab.
Rückgabewertkeiner
QuerverweisVF_FFT,   VF_convolve,   VF_autocorr,   VF_xcorr,   VF_spectrum,   VF_smooth,   VF_biquad

VectorLib Inhaltsverzeichnis  OptiVec Home