kopierende Konstruktoren und Prüffunktionen in fftunit.pas

1 files changed, 87 insertions, 5 deletions

diff --git a/fftunit.pas b/fftunit.pas
index f78935f..e3f73ea 100644
--- a/fftunit.pas
+++ b/fftunit.pas
@@ -17,9 +17,10 @@ type
     len,hlen:      longint;
     res,ims:       tExtendedArray;
     ino,outo:      tFFTDatenordnung;
-  public
     procedure dumpResIms;
-    constructor create(laenge: longint; inputOrdnung,outputOrdnung: tFFTDatenordnung);
+  public
+    constructor create(laenge: longint; inputOrdnung,outputOrdnung: tFFTDatenordnung); overload;
+    constructor create(original: tFFTAlgorithmus); overload;
     destructor destroy; override;
     procedure laden(invers: boolean; q: pSingle; schritt: longint); overload; virtual;
     procedure laden(invers: boolean; q: pDouble; schritt: longint); overload; virtual;
@@ -30,6 +31,8 @@ type
     procedure speichern(invers: boolean; z: pDouble; schritt: longint); overload; virtual;
     procedure speichern(invers: boolean; z: pExtended; schritt: longint); overload; virtual;
     procedure speichern(invers: boolean; zRe,zIm: tExtendedArray); overload; virtual;
+    procedure summen(amAnfang: boolean; var energie: extended; var nurNullen: boolean);
+    function dumpParams: string;
   end;
 
   tFFTCooleyTukey = class(tFFTAlgorithmus)
@@ -37,7 +40,8 @@ type
     wre,wim: tExtendedArray;
     perm:    tLongintArray;
   public
-    constructor create(laenge: longint; inputOrdnung,outputOrdnung: tFFTDatenordnung);
+    constructor create(laenge: longint; inputOrdnung,outputOrdnung: tFFTDatenordnung); overload;
+    constructor create(original: tFFTCooleyTukey); overload;
     destructor destroy; override;
     procedure laden(invers: boolean; q: pSingle; schritt: longint); overload; override;
     procedure laden(invers: boolean; q: pDouble; schritt: longint); overload; override;
@@ -51,12 +55,14 @@ type
     rRe,rIm,sRe,sIm: array of extended;
     subFFT:          tFFTCooleyTukey;
   public
-    constructor create(laenge: longint; inputOrdnung,outputOrdnung: tFFTDatenordnung);
+    constructor create(laenge: longint; inputOrdnung,outputOrdnung: tFFTDatenordnung); overload;
+    constructor create(original: tFFTBluestein); overload;
     destructor destroy; override;
     procedure ausfuehren; override;
   end;
 
-  function createFFTAlgorithmus(laenge: longint; inputOrdnung,outputOrdnung: tFFTDatenordnung): tFFTAlgorithmus;
+  function createFFTAlgorithmus(laenge: longint; inputOrdnung,outputOrdnung: tFFTDatenordnung): tFFTAlgorithmus; overload;
+  function createFFTAlgorithmus(original: tFFTAlgorithmus): tFFTAlgorithmus; overload;
 
 implementation
 
@@ -76,6 +82,16 @@ begin
     result:=tFFTBluestein.create(laenge,inputOrdnung,outputOrdnung);
 end;
 
+function createFFTAlgorithmus(original: tFFTAlgorithmus): tFFTAlgorithmus;
+begin
+  if original is tFFTCooleyTukey then
+    result:=tFFTCooleyTukey.create(original as tFFTCooleyTukey)
+  else if original is tFFTBluestein then
+    result:=tFFTBluestein.create(original as tFFTBluestein)
+  else
+    fehler('Unbekannter FFT-Algorithmus-Typ '''+original.className+'!');
+end;
+
 // tFFTAlgorithmus *************************************************************
 {$DEFINE tFFTAlgorithmus}
 
@@ -92,6 +108,19 @@ begin
   setlength(ims,0);
 end;
 
+constructor tFFTAlgorithmus.create(original: tFFTAlgorithmus);
+begin
+  inherited create;
+  ino:=original.ino;
+  outo:=original.outo;
+  len:=original.len;
+  hlen:=original.hlen;
+  fillchar(res,sizeof(res),#0);
+  setlength(res,0);
+  fillchar(ims,sizeof(ims),#0);
+  setlength(ims,0);
+end;
+
 destructor tFFTAlgorithmus.destroy;
 begin
   setlength(res,0);
@@ -137,6 +166,29 @@ procedure tFFTAlgorithmus.speichern(invers: boolean; zRe,zIm: tExtendedArray);
 {$INCLUDE fftunit.inc}
 {$UNDEF fftunitGetrenntSpeichern}
 
+procedure tFFTAlgorithmus.summen(amAnfang: boolean; var energie: extended; var nurNullen: boolean);
+var
+  i:    longint;
+  tmpE: extended;
+begin
+  tmpE:=0;
+  for i:=0 to len-1 do begin
+    tmpE:=tmpE + sqr(res[i]) + sqr(ims[i]);
+    nurNullen:=nurNullen and (res[i]=0) and (ims[i]=0);
+  end;
+  {$IFDEF fftNormierung}
+  if amAnfang then
+    energie:=energie + tmpE*len
+  else
+  {$ENDIF}
+    energie:=energie + tmpE;
+end;
+
+function tFFTAlgorithmus.dumpParams: string;
+begin
+  result:=className+': '+inttostr(len)+' ('+inttostr(hlen)+')';
+end;
+
 {$UNDEF tFFTAlgorithmus}
 
 // tFFTCooleyTukey *************************************************************
@@ -168,6 +220,19 @@ begin
   end;
 end;
 
+constructor tFFTCooleyTukey.create(original: tFFTCooleyTukey);
+begin
+  inherited create(original);
+  setlength(res,length(original.res));
+  setlength(ims,length(original.ims));
+  setlength(wre,length(original.wre));
+  move(original.wre[0],wre[0],sizeof(wre[0])*length(wre));
+  setlength(wim,length(original.wim));
+  move(original.wim[0],wim[0],sizeof(wim[0])*length(wim));
+  setlength(perm,length(original.perm));
+  move(original.perm[0],perm[0],sizeof(perm[0])*length(perm));
+end;
+
 destructor tFFTCooleyTukey.destroy;
 begin
   setlength(wre,0);
@@ -259,6 +324,23 @@ begin
   {$ENDIF}
 end;
 
+constructor tFFTBluestein.create(original: tFFTBluestein);
+begin
+  inherited create(original);
+  setlength(res,length(original.res));
+  setlength(ims,length(original.ims));
+  setlength(rRe,length(original.rRe));
+  move(original.rRe[0],rRe[0],sizeof(rRe[0])*length(rRe));
+  setlength(rIm,length(original.rIm));
+  move(original.rIm[0],rIm[0],sizeof(rIm[0])*length(rIm));
+  setlength(sRe,length(original.sRe));
+  move(original.sRe[0],sRe[0],sizeof(sRe[0])*length(sRe));
+  setlength(sIm,length(original.sIm));
+  move(original.sIm[0],sIm[0],sizeof(sIm[0])*length(sIm));
+
+  subFFT:=tFFTCooleyTukey.create(original.subFFT);
+end;
+
 destructor tFFTBluestein.destroy;
 begin
   setlength(rRe,0);