fftunit.pas: str <--> fftDo - Konversionen neu

1 files changed, 112 insertions, 55 deletions

diff --git a/fftunit.pas b/fftunit.pas
index e3f73ea..b4b03bf 100644
--- a/fftunit.pas
+++ b/fftunit.pas
@@ -37,7 +37,7 @@ type
 
   tFFTCooleyTukey = class(tFFTAlgorithmus)
   private
-    wre,wim: tExtendedArray;
+    wRe,wIm: tExtendedArray;
     perm:    tLongintArray;
   public
     constructor create(laenge: longint; inputOrdnung,outputOrdnung: tFFTDatenordnung); overload;
@@ -64,10 +64,13 @@ type
   function createFFTAlgorithmus(laenge: longint; inputOrdnung,outputOrdnung: tFFTDatenordnung): tFFTAlgorithmus; overload;
   function createFFTAlgorithmus(original: tFFTAlgorithmus): tFFTAlgorithmus; overload;
 
+  function strToFftDo(out fftDo: tFFTDatenordnung; s: string): boolean;
+  function fftDoToStr(fftDo: tFFTDatenordnung): string;
+
 implementation
 
 uses
-  math;
+  math, myStringListUnit;
 
 // allgemeine Funktionen *******************************************************
 
@@ -92,6 +95,62 @@ begin
     fehler('Unbekannter FFT-Algorithmus-Typ '''+original.className+'!');
 end;
 
+function strToFftDo(out fftDo: tFFTDatenordnung; s: string): boolean;
+var
+  bekannteBefehle: tMyStringList;
+begin
+  result:=true;
+  bekannteBefehle:=tMyStringList.create;
+  if istDasBefehl('Realteile:Imaginärteile',s,bekannteBefehle,false) then begin
+    fftDo:=doResIms;
+    bekannteBefehle.free;
+    exit;
+  end;
+  if istDasBefehl('Realteile:Imaginärteile umgedreht',s,bekannteBefehle,false) then begin
+    fftDo:=doResSmi;
+    bekannteBefehle.free;
+    exit;
+  end;
+  if istDasBefehl('Beträge',s,bekannteBefehle,false) then begin
+    fftDo:=doBetr;
+    bekannteBefehle.free;
+    exit;
+  end;
+  if istDasBefehl('Betragsquadrate',s,bekannteBefehle,false) then begin
+    fftDo:=doBetrQdr;
+    bekannteBefehle.free;
+    exit;
+  end;
+  bekannteBefehle.sort;
+  gibAus('Kenne Nachbereitungsvariante '''+s+''' nicht bei Erstellung einer FFT!'#10'Ich kenne:'#10+bekannteBefehle.text,3);
+  bekannteBefehle.free;
+  result:=false;
+end;
+
+function fftDoToStr(fftDo: tFFTDatenordnung): string;
+begin
+  case fftDo of
+    doResIms:
+      result:='Realteile:Imaginärteile';
+    doResSmi:
+      result:='Realteile:Imaginärteile umgedreht';
+    doAlleResIms:
+      result:='alle Realteile:Imaginärteile';
+    doAlleResSmi:
+      result:='alle Realteile:Imaginärteile umgedreht';
+    doRes:
+      result:='Realteile';
+    doBetr:
+      result:='Beträge';
+    doBetrQdr:
+      result:='Betragsquadrate';
+    doGetrennt:
+      result:='Realteile und Imaginärteile getrennt';
+    else
+      result:='unbekannte fftDatenOrdnung';
+  end{of case};
+end;
+
 // tFFTAlgorithmus *************************************************************
 {$DEFINE tFFTAlgorithmus}
 
@@ -102,10 +161,10 @@ begin
   outo:=outputOrdnung;
   len:=laenge;
   hlen:=laenge div 2;
-  fillchar(res,sizeof(res),#0);
-  setlength(res,0);
-  fillchar(ims,sizeof(ims),#0);
-  setlength(ims,0);
+  fillchar(res,sizeOf(res),#0);
+  setLength(res,0);
+  fillchar(ims,sizeOf(ims),#0);
+  setLength(ims,0);
 end;
 
 constructor tFFTAlgorithmus.create(original: tFFTAlgorithmus);
@@ -115,16 +174,16 @@ begin
   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);
+  fillchar(res,sizeOf(res),#0);
+  setLength(res,0);
+  fillchar(ims,sizeOf(ims),#0);
+  setLength(ims,0);
 end;
 
 destructor tFFTAlgorithmus.destroy;
 begin
-  setlength(res,0);
-  setlength(ims,0);
+  setLength(res,0);
+  setLength(ims,0);
   inherited destroy;
 end;
 
@@ -186,7 +245,7 @@ end;
 
 function tFFTAlgorithmus.dumpParams: string;
 begin
-  result:=className+': '+inttostr(len)+' ('+inttostr(hlen)+')';
+  result:=className+': '+intToStr(len)+' ('+intToStr(hlen)+')';
 end;
 
 {$UNDEF tFFTAlgorithmus}
@@ -199,14 +258,12 @@ var
   i,j,loglen: longint;
 begin
   inherited create(laenge,inputOrdnung,outputOrdnung);
-
-  setlength(res,len);
-  setlength(ims,len);
-
+  setLength(res,len);
+  setLength(ims,len);
   loglen:=round(ln(len)/ln(2));
-  setlength(wre,hlen);
-  setlength(wim,hlen);
-  setlength(perm,len);
+  setLength(wRe,hlen);
+  setLength(wIm,hlen);
+  setLength(perm,len);
   for i:=0 to len-1 do begin
     res[i]:=nan;
     ims[i]:=nan;
@@ -215,29 +272,29 @@ begin
       perm[i]:=perm[i] or (byte(odd(i shr j)) shl (loglen-1-j));
   end;
   for i:=0 to hlen-1 do begin
-    wre[i]:=cos(2*pi*i/len);
-    wim[i]:=sin(2*pi*i/len);
+    wRe[i]:=cos(2*pi*i/len);
+    wIm[i]:=sin(2*pi*i/len);
   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));
+  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);
-  setlength(wim,0);
-  setlength(perm,0);
+  setLength(wRe,0);
+  setLength(wIm,0);
+  setLength(perm,0);
   inherited destroy;
 end;
 
@@ -296,18 +353,18 @@ var
   i:      longint;
 begin
   inherited create(laenge,inputOrdnung,outputOrdnung);
-  setlength(res,round(power(2,ceil(ln(2*len-1)/ln(2)))));
-  setlength(ims,length(res));
-  setlength(rRe,length(res));
-  setlength(rIm,length(res));
-  setlength(sRe,length(res));
-  setlength(sIm,length(res));
+  setLength(res,round(power(2,ceil(ln(2*len-1)/ln(2)))));
+  setLength(ims,length(res));
+  setLength(rRe,length(res));
+  setLength(rIm,length(res));
+  setLength(sRe,length(res));
+  setLength(sIm,length(res));
   subFFT:=tFFTCooleyTukey.create(length(res),doGetrennt,doGetrennt);
 
   for i:=0 to subFFT.len-1 do begin
     e:=sqr(min(i,subFFT.len-i))*pi/len;
-    rRe[i]:=Cos(e);
-    rIm[i]:=Sin(e);
+    rRe[i]:=cos(e);
+    rIm[i]:=sin(e);
   end;
 
   preFFT:=tFFTCooleyTukey.create(length(rRe),doGetrennt,doGetrennt);
@@ -327,26 +384,26 @@ 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));
+  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);
-  setlength(rIm,0);
-  setlength(sRe,0);
-  setlength(sIm,0);
+  setLength(rRe,0);
+  setLength(rIm,0);
+  setLength(sRe,0);
+  setLength(sIm,0);
   subFFT.free;
   res:=nil;
   ims:=nil;