{$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: tExtendedArray);
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:
      for i:=0 to len-1 do begin
        {$IFDEF tFFTCooleyTukey}
        res[perm[i]]:=qRe[i] {$IFDEF fftNormierung} * lenFak{$ENDIF};
        ims[perm[i]]:=qIm[i] * inv {$IFDEF fftNormierung} * lenFak{$ENDIF};
        {$ELSE}
        res[i]:=qRe[i] {$IFDEF fftNormierung} * lenFak{$ENDIF};
        ims[i]:=qIm[i] * 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: tExtendedArray);
var
  i,inv: longint;
begin
  inv:=1-2*byte(invers);
  case outo of
    doGetrennt:
      for i:=0 to len-1 do begin
        zRe[i]:=res[i];
        zIm[i]:=ims[i] * inv;
      end;
    else
      fehler('Diese Outputordnung ist in dieser Methode nicht implementiert!');;
  end{of case};
end;
{$ENDIF}