{$IFDEF fftunitLaden}
//procedure tFFTAlgorithmus.laden(invers: boolean; const q: single; schritt: longint);
var
  i,inv:  longint;
  {$IFDEF fftNormierung}
  lenFak: extended;
  {$ENDIF}
begin
  inv:=1-2*byte(invers);
  {$IFDEF fftNormierung}
  lenFak:=1/sqrt(len);
  {$ENDIF}
  case inO of
    doRes:
      for i:=0 to len-1 do begin
        {$IFDEF tFFTCooleyTukey}
        res[perm[i]]:=(q+i*schritt)^ {$IFDEF fftNormierung} * lenFak{$ENDIF};
        ims[perm[i]]:=0;
        {$ELSE}
        res[i]:=(q+i*schritt)^ {$IFDEF fftNormierung} * lenFak{$ENDIF};
        ims[i]:=0;
        {$ENDIF}
      end;
    doAlleResIms:
      for i:=0 to len-1 do begin
        {$IFDEF tFFTCooleyTukey}
        res[perm[i]]:=(q+i*schritt)^ {$IFDEF fftNormierung} * lenFak{$ENDIF};
        ims[perm[i]]:=(q+(i+len)*schritt)^ * inv {$IFDEF fftNormierung} * lenFak{$ENDIF};
        {$ELSE}
        res[i]:=(q+i*schritt)^ {$IFDEF fftNormierung} * lenFak{$ENDIF};
        ims[i]:=(q+(i+len)*schritt)^ * inv {$IFDEF fftNormierung} * lenFak{$ENDIF};
        {$ENDIF}
      end;
    doAlleResSmi:
      for i:=0 to hLen + (len and $1) - 1 do begin
        {$IFDEF tFFTCooleyTukey}
        res[perm[i]]:=(q+i*schritt)^ {$IFDEF fftNormierung} * lenFak{$ENDIF};
        ims[perm[i]]:=(q+(2*len-1-i)*schritt)^ * inv {$IFDEF fftNormierung} * lenFak{$ENDIF};
        {$ELSE}
        res[i]:=(q+i*schritt)^ {$IFDEF fftNormierung} * lenFak{$ENDIF};
        ims[i]:=(q+(2*len-1-i)*schritt)^ * inv {$IFDEF fftNormierung} * lenFak{$ENDIF};
        {$ENDIF}
      end;
    doResIms: begin
      res[0]:=q^ {$IFDEF fftNormierung} * lenFak{$ENDIF};                // perm[0]=0
      ims[0]:=0;
      for i:=1 to hLen + (len and $1) - 1 do begin
        {$IFDEF tFFTCooleyTukey}
        res[perm[i]]:=(q+i*schritt)^ {$IFDEF fftNormierung} * lenFak{$ENDIF};
        ims[perm[i]]:=(q+(i+hLen)*schritt)^ * inv {$IFDEF fftNormierung} * lenFak{$ENDIF};
        res[perm[len-i]]:=res[perm[i]];
        ims[perm[len-i]]:=-ims[perm[i]];
        {$ELSE}
        res[i]:=(q+i*schritt)^ {$IFDEF fftNormierung} * lenFak{$ENDIF};
        ims[i]:=(q+(i+hLen)*schritt)^ * inv {$IFDEF fftNormierung} * lenFak{$ENDIF};
        res[len-i]:=res[i];
        ims[len-i]:=-ims[i];
        {$ENDIF}
      end;
      if not odd(len) then begin
        {$IFDEF tFFTCooleyTukey}
        res[1]:=(q+hLen*schritt)^ {$IFDEF fftNormierung} * lenFak{$ENDIF}; // perm[hLen]=1
        ims[1]:=0;
        {$ELSE}
        res[hLen]:=(q+hLen*schritt)^ {$IFDEF fftNormierung} * lenFak{$ENDIF};
        ims[hLen]:=0;
        {$ENDIF}
      end;
    end;
    doResSmi: begin
      res[0]:=q^ {$IFDEF fftNormierung} * lenFak{$ENDIF};                // perm[0]=0
      ims[0]:=0;
      for i:=1 to hLen + (len and $1) - 1 do begin
        {$IFDEF tFFTCooleyTukey}
        res[perm[i]]:=(q+i*schritt)^ {$IFDEF fftNormierung} * lenFak{$ENDIF};
        ims[perm[i]]:=(q+(len-i)*schritt)^ * inv {$IFDEF fftNormierung} * lenFak{$ENDIF};
        res[perm[len-i]]:=res[perm[i]];
        ims[perm[len-i]]:=-ims[perm[i]];
        {$ELSE}
        res[i]:=(q+i*schritt)^ {$IFDEF fftNormierung} * lenFak{$ENDIF};
        ims[i]:=(q+(len-i)*schritt)^ * inv {$IFDEF fftNormierung} * lenFak{$ENDIF};
        res[len-i]:=res[i];
        ims[len-i]:=-ims[i];
        {$ENDIF}
      end;
      if not odd(len) then begin
        {$IFDEF tFFTCooleyTukey}
        res[1]:=(q+hLen*schritt)^ {$IFDEF fftNormierung} * lenFak{$ENDIF}; // perm[hLen]=1
        ims[1]:=0;
        {$ELSE}
        res[hLen]:=(q+hLen*schritt)^ {$IFDEF fftNormierung} * lenFak{$ENDIF};
        ims[hLen]:=0;
        {$ENDIF}
      end;
    end;
    doBetr,doBetrQdr:
      fehler('Ich brauche mehr als Beträge oder Betragsquadrate um eine FFT auszurechnen!');
    else
      fehler('Diese Inputordnung ist in dieser Methode nicht implementiert!');;
  end{of case};
end;
{$ENDIF}

{$IFDEF fftunitGetrenntLaden}
//procedure tFFTAlgorithmus.laden(invers: boolean; qRe,qIm: pSingle; schritt: longint);
var
  i,inv:  longint;
  {$IFDEF fftNormierung}
  lenFak: extended;
  {$ENDIF}
begin
  inv:=1-2*byte(invers);
  {$IFDEF fftNormierung}
  lenFak:=1/sqrt(len);
  {$ENDIF}
  case inO of
    doGetrennt,doAlleResIms,doAlleResSmi:
      // Real- und Imaginärteile sind _immer_ in gleicher Reihenfolge;
      // die ggf. verdrehte Dimension ist senkrecht dazu! (benötigt für fft2d)
      for i:=0 to len-1 do begin
        {$IFDEF tFFTCooleyTukey}
        res[perm[i]]:=(qRe+i*schritt)^ {$IFDEF fftNormierung} * lenFak{$ENDIF};
        ims[perm[i]]:=(qIm+i*schritt)^ * inv {$IFDEF fftNormierung} * lenFak{$ENDIF};
        {$ELSE}
        res[i]:=(qRe+i*schritt)^ {$IFDEF fftNormierung} * lenFak{$ENDIF};
        ims[i]:=(qIm+i*schritt)^ * inv {$IFDEF fftNormierung} * lenFak{$ENDIF};
        {$ENDIF}
      end;
    else
      fehler('Diese Inputordnung ist in dieser Methode nicht implementiert!');;
  end{of case};
end;
{$ENDIF}

{$IFDEF fftunitSpeichern}
//procedure tFFTAlgorithmus.speichern(invers: boolean; var z: single; schritt: longint);
var
  i,inv: longint;
begin
  inv:=1-2*byte(invers);
  case outO of
    doRes:
      for i:=0 to len-1 do
        (z+i*schritt)^:=res[i];
    doAlleResIms:
      for i:=0 to len-1 do begin
        (z+i*schritt)^:=res[i];
        (z+(i+len)*schritt)^:=ims[i] * inv;
      end;
    doAlleResSmi:
      for i:=0 to len-1 do begin
        (z+i*schritt)^:=res[i];
        (z+(2*len-1-i)*schritt)^:=ims[i] * inv;
      end;
    doResIms: begin
      z^:=res[0];
      for i:=1 to hLen + (len and $1) - 1 do begin
        (z+i*schritt)^:=res[i];
        (z+(i+hLen)*schritt)^:=ims[i] * inv;
      end;
      if not odd(len) then
        (z+hLen*schritt)^:=res[hLen];
    end;
    doResSmi: begin
      z^:=res[0];
      for i:=1 to hLen + (len and $1) - 1 do begin
        (z+i*schritt)^:=res[i];
        (z+(len-i)*schritt)^:=ims[i] * inv;
      end;
      if not odd(len) then
        (z+hLen*schritt)^:=res[hLen];
    end;
    doBetr:
      for i:=0 to len-1 do
        (z+i*schritt)^:=sqrt(sqr(res[i])+sqr(ims[i]));
    doBetrQdr:
      for i:=0 to len-1 do
        (z+i*schritt)^:=sqr(res[i])+sqr(ims[i]);
    else
      fehler('Diese Outputordnung ist in dieser Methode nicht implementiert!');;
  end{of case};
end;
{$ENDIF}

{$IFDEF fftunitGetrenntSpeichern}
//procedure tFFTAlgorithmus.speichern(invers: boolean; zRe,zIm: pSingle; schritt: longint);
var
  i,inv: longint;
begin
  inv:=1-2*byte(invers);
  case outO of
    doGetrennt,doAlleResIms,doAlleResSmi:
      // Real- und Imaginärteile sind _immer_ in gleicher Reihenfolge;
      // die ggf. verdrehte Dimension ist senkrecht dazu! (benötigt für fft2d)
      for i:=0 to len-1 do begin
        (zRe+i*schritt)^:=res[i];
        (zIm+i*schritt)^:=ims[i] * inv;
      end;
    else
      fehler('Diese Outputordnung ist in dieser Methode nicht implementiert!');;
  end{of case};
end;
{$ENDIF}