sollte jetzt wirklich gehen ...

1 files changed, 271 insertions, 277 deletions

diff --git a/werteunit.pas b/werteunit.pas
index 8b9f9d3..0786d09 100644
--- a/werteunit.pas
+++ b/werteunit.pas
@@ -20,10 +20,10 @@ type
   private
   public
     werte:                                       array of wgen;
-    params:                                      pTExtrainfos;
-    constructor create(ps: pTExtrainfos); overload;
-    constructor create(original: pTLLWerteSingle; ps: pTExtrainfos; xmin,xmax: longint); overload;
-    constructor create(original: pTLLWerteDouble; ps: pTExtrainfos; xmin,xmax: longint); overload;
+    params:                                      tExtrainfos;
+    constructor create(ps: tExtrainfos); overload;
+    constructor create(original: pTLLWerteSingle; ps: tExtrainfos; xmin,xmax: longint); overload;
+    constructor create(original: pTLLWerteDouble; ps: tExtrainfos; xmin,xmax: longint); overload;
     procedure kopiereVon(st: boolean; original: pTLLWerteSingle); overload;
     procedure kopiereVon(st: boolean; original: pTLLWerteDouble); overload;
     procedure kopiereVon(st: boolean; original: pTLLWerteSingle; xmin,xmax: longint); overload;
@@ -68,21 +68,21 @@ type
 
 implementation
 
-constructor tLLWerte.create(ps: pTExtrainfos);
+constructor tLLWerte.create(ps: tExtrainfos);
 begin
  inherited create;
  params:=ps;
  setlength(werte,0);
 end;
 
-constructor tLLWerte.create(original: pTLLWerteSingle; ps: pTExtrainfos; xmin,xmax: longint);
+constructor tLLWerte.create(original: pTLLWerteSingle; ps: tExtrainfos; xmin,xmax: longint);
 begin
   inherited create;
   params:=ps;
   kopiereVon(false,original,xmin,xmax);
 end;
 
-constructor tLLWerte.create(original: pTLLWerteDouble; ps: pTExtrainfos; xmin,xmax: longint);
+constructor tLLWerte.create(original: pTLLWerteDouble; ps: tExtrainfos; xmin,xmax: longint);
 begin
   inherited create;
   params:=ps;
@@ -91,47 +91,45 @@ end;
 
 procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteSingle);
 begin
-  kopiereVon(st,original,0,original^.params^.xsteps-1);
+  kopiereVon(st,original,0,original^.params.xsteps-1);
 end;
 
 procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteDouble);
 begin
-  kopiereVon(st,original,0,original^.params^.xsteps-1);
+  kopiereVon(st,original,0,original^.params.xsteps-1);
 end;
 
 procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteSingle; xmin,xmax: longint);
 begin
-  kopiereVon(st,original,xmin,xmax,0,original^.params^.tsiz-1);
+  kopiereVon(st,original,xmin,xmax,0,original^.params.tsiz-1);
 end;
 
 procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteDouble; xmin,xmax: longint);
 begin
-  kopiereVon(st,original,xmin,xmax,0,original^.params^.tsiz-1);
+  kopiereVon(st,original,xmin,xmax,0,original^.params.tsiz-1);
 end;
 
 procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteSingle; xmin,xmax,tmin,tmax: longint);
 var i,j: longint;
 begin
  inherited create;
- tmax:=min(tmax,original^.params^.tsiz-1);
+ tmax:=min(tmax,original^.params.tsiz-1);
  tmin:=max(tmin,0);
- params^.tsiz:=tmax+1-tmin;
- xmax:=min(xmax,original^.params^.xsteps-1);
+ params.tsiz:=tmax+1-tmin;
+ xmax:=min(xmax,original^.params.xsteps-1);
  xmin:=max(xmin,0);
- params^.xsteps:=xmax+1-xmin;
- params^.xstart:=original^.params^.xstart+(original^.params^.xstop-original^.params^.xstart)/(original^.params^.xsteps-1)*xmin;
- params^.xstop:=original^.params^.xstart+(original^.params^.xstop-original^.params^.xstart)/(original^.params^.xsteps-1)*xmax;
- params^.tstart:=original^.params^.tstart+(original^.params^.tstop-original^.params^.tstart)/(original^.params^.tsiz-1)*tmin;
- params^.tstop:=original^.params^.tstart+(original^.params^.tstop-original^.params^.tstart)/(original^.params^.tsiz-1)*tmax;
- params^.maxW:=0;
- params^.minW:=0;
- params^.np:=original^.params^.np;
- params^.beta:=original^.params^.beta;
+ params.xsteps:=xmax+1-xmin;
+ params.transformationen.kopiereVon(original^.params.transformationen);
+ params.transformationen.addAusschnitt(xmin,xmax,tmin,tmax);
+ params.maxW:=0;
+ params.minW:=0;
+ params.np:=original^.params.np;
+ params.beta:=original^.params.beta;
  if not st then begin
    holeRam(0);
    for i:=xmin to xmax do
      for j:=tmin to tmax do
-       werte[i-xmin+(j-tmin)*params^.xsteps]:=original^.werte[i+j*original^.params^.xsteps];
+       werte[i-xmin+(j-tmin)*params.xsteps]:=original^.werte[i+j*original^.params.xsteps];
  end;
 end;
 
@@ -139,25 +137,23 @@ procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteDouble; xmin,xmax,
 var i,j: longint;
 begin
  inherited create;
- tmax:=min(tmax,original^.params^.tsiz-1);
+ tmax:=min(tmax,original^.params.tsiz-1);
  tmin:=max(tmin,0);
- params^.tsiz:=tmax+1-tmin;
- xmax:=min(xmax,original^.params^.xsteps-1);
+ params.tsiz:=tmax+1-tmin;
+ xmax:=min(xmax,original^.params.xsteps-1);
  xmin:=max(xmin,0);
- params^.xsteps:=xmax+1-xmin;
- params^.xstart:=original^.params^.xstart+(original^.params^.xstop-original^.params^.xstart)/(original^.params^.xsteps-1)*xmin;
- params^.xstop:=original^.params^.xstart+(original^.params^.xstop-original^.params^.xstart)/(original^.params^.xsteps-1)*xmax;
- params^.tstart:=original^.params^.tstart+(original^.params^.tstop-original^.params^.tstart)/(original^.params^.tsiz-1)*tmin;
- params^.tstop:=original^.params^.tstart+(original^.params^.tstop-original^.params^.tstart)/(original^.params^.tsiz-1)*tmax;
- params^.maxW:=0;
- params^.minW:=0;
- params^.np:=original^.params^.np;
- params^.beta:=original^.params^.beta;
+ params.xsteps:=xmax+1-xmin;
+ params.transformationen.kopiereVon(original^.params.transformationen);
+ params.transformationen.addAusschnitt(xmin,xmax,tmin,tmax);
+ params.maxW:=0;
+ params.minW:=0;
+ params.np:=original^.params.np;
+ params.beta:=original^.params.beta;
  if not st then begin
    holeRam(0);
    for i:=xmin to xmax do
      for j:=tmin to tmax do
-       werte[i-xmin+(j-tmin)*params^.xsteps]:=original^.werte[i+j*original^.params^.xsteps];
+       werte[i-xmin+(j-tmin)*params.xsteps]:=original^.werte[i+j*original^.params.xsteps];
  end;
 end;
 
@@ -167,7 +163,7 @@ var i,j,k,l: longint;
 begin
   for i:=tmin to tmax do
     for j:=xmin to xmax do
-      werte[j+i*params^.xsteps]:=0;
+      werte[j+i*params.xsteps]:=0;
   for i:=0 to length(ZPs)-1 do
     for j:=0 to 1 do
       for k:=0 to 1 do
@@ -175,20 +171,20 @@ begin
            (ZPs[i]['y']+k>=tmin) and (ZPs[i]['y']+k<=tmax) then begin
           tmp:=original^.werte[i];
           if (vb.count>0) or (nb.count>0) then
-            tmp:=(tmp-original^.params^.minW)/(original^.params^.maxW-original^.params^.minW);
+            tmp:=(tmp-original^.params.minW)/(original^.params.maxW-original^.params.minW);
           for l:=0 to vb.count-1 do
             vb[l].transformiereWert(tmp);
           tmp:=tmp * (ZGs[i]['x'] * (2*j-1) + 1-j) * (ZGs[i]['y'] * (2*k-1) + 1-k);
-          werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params^.xsteps]:=
-            werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params^.xsteps] +
+          werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps]:=
+            werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps] +
             tmp;
         end;
   for i:=tmin to tmax do
     for j:=xmin to xmax do begin
-      tmp:=werte[j + i*params^.xsteps] / ZAs[j + i*params^.xsteps];
+      tmp:=werte[j + i*params.xsteps] / ZAs[j + i*params.xsteps];
       for k:=0 to nb.count-1 do
         nb[k].transformiereWert(tmp);
-      werte[j + i*params^.xsteps]:=tmp;
+      werte[j + i*params.xsteps]:=tmp;
     end;
 end;
 
@@ -198,7 +194,7 @@ var i,j,k,l: longint;
 begin
  for i:=tmin to tmax do
    for j:=xmin to xmax do
-     werte[j+i*params^.xsteps]:=0;
+     werte[j+i*params.xsteps]:=0;
  for i:=0 to length(ZPs)-1 do
    for j:=0 to 1 do
      for k:=0 to 1 do
@@ -206,20 +202,20 @@ begin
           (ZPs[i]['y']+k>=tmin) and (ZPs[i]['y']+k<=tmax) then begin
          tmp:=original^.werte[i];
          if (vb.count>0) or (nb.count>0) then
-           tmp:=(tmp-original^.params^.minW)/(original^.params^.maxW-original^.params^.minW);
+           tmp:=(tmp-original^.params.minW)/(original^.params.maxW-original^.params.minW);
          for l:=0 to vb.count-1 do
            vb[l].transformiereWert(tmp);
          tmp:=tmp * (ZGs[i]['x'] * (2*j-1) + 1-j) * (ZGs[i]['y'] * (2*k-1) + 1-k);
-         werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params^.xsteps]:=
-           werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params^.xsteps] +
+         werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps]:=
+           werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps] +
            tmp;
        end;
  for i:=tmin to tmax do
    for j:=xmin to xmax do begin
-     tmp:=werte[j + i*params^.xsteps] / ZAs[j + i*params^.xsteps];
+     tmp:=werte[j + i*params.xsteps] / ZAs[j + i*params.xsteps];
      for k:=0 to nb.count-1 do
        nb[k].transformiereWert(tmp);
-     werte[j + i*params^.xsteps]:=tmp;
+     werte[j + i*params.xsteps]:=tmp;
    end;
 end;
 
@@ -304,8 +300,8 @@ begin
      reset(f,1);
      blockread(f,tmpi,sizeof(integer));
      dec(tmpi);
-     if tmpi-round(params^.tstart/dateien[i].groeszenFaktor)<>i then begin
-       gibAus('Datei '''+dateien[i].Name+''' kommt nicht an '+inttostr(i)+'-ter Stelle, wie sie sollte, sondern an '+inttostr(tmpi-round(params^.tstart/dateien[i].groeszenFaktor))+'-ter.',3);
+     if tmpi-round(params.tstart/dateien[i].groeszenFaktor)<>i then begin
+       gibAus('Datei '''+dateien[i].Name+''' kommt nicht an '+inttostr(i)+'-ter Stelle, wie sie sollte, sondern an '+inttostr(tmpi-round(params.tstart/dateien[i].groeszenFaktor))+'-ter.',3);
        writeln(tmpi);
        close(f);
        exit;
@@ -326,9 +322,9 @@ begin
              blockread(f,tmpe,sizeof(extended)); // xstart
          end{of Case};
          tmpe:=tmpe*dateien[i].groeszenFaktor;
-         if j=0 then params^.xstart:=tmpe;
-         if tmpe<>params^.xstart then begin
-           gibAus('Falscher linker Rand in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(params^.xstart)+'!',3);
+         if j=0 then params.transformationen.xstart:=tmpe;
+         if tmpe<>params.xstart then begin
+           gibAus('Falscher linker Rand in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(params.xstart)+'!',3);
            close(f);
            exit;
          end;
@@ -341,30 +337,30 @@ begin
              blockread(f,tmpe,sizeof(extended)); // xstop
          end{of Case};
          tmpe:=tmpe*dateien[i].groeszenFaktor;
-         if j=0 then params^.xstop:=tmpe;
-         if tmpe<>params^.xstop then begin
-           gibAus('Falscher rechter Rand in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(params^.xstop)+'!',3);
+         if j=0 then params.transformationen.xstop:=tmpe;
+         if tmpe<>params.xstop then begin
+           gibAus('Falscher rechter Rand in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(params.xstop)+'!',3);
            close(f);
            exit;
          end;
          blockread(f,tmpi,sizeof(integer)); // xsteps
-         if tmpi<>params^.xsteps then begin
-           gibAus('Falsche Anzahl an x-Schritten in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+inttostr(tmpi)+' statt '+myfloattostr(params^.xsteps)+'!',3);
+         if tmpi<>params.xsteps then begin
+           gibAus('Falsche Anzahl an x-Schritten in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+inttostr(tmpi)+' statt '+myfloattostr(params.xsteps)+'!',3);
            close(f);
            exit;
          end;
          if ((sizeof(wgen) = sizeof(single)) and (Dateien[i].Genauigkeit=gSingle)) or
             ((sizeof(wgen) = sizeof(double)) and (Dateien[i].Genauigkeit=gExtended)) then
-           blockread(f,werte[(j+Dateien[i].t0abs)*params^.xsteps],params^.xsteps*sizeof(wgen))
+           blockread(f,werte[(j+Dateien[i].t0abs)*params.xsteps],params.xsteps*sizeof(wgen))
          else begin
-           setlength(sa,params^.xsteps);
-           blockread(f,sa[0],params^.xsteps*sizeof(single));
-           for k:=0 to params^.xsteps-1 do
-             werte[(j+Dateien[i].t0abs)*params^.xsteps+k]:=sa[k];
+           setlength(sa,params.xsteps);
+           blockread(f,sa[0],params.xsteps*sizeof(single));
+           for k:=0 to params.xsteps-1 do
+             werte[(j+Dateien[i].t0abs)*params.xsteps+k]:=sa[k];
          end;
          if dateien[i].faktor/sqr(dateien[i].groeszenFaktor)<>1 then
-           for k:=0 to params^.xsteps-1 do
-             werte[(j+Dateien[i].t0abs)*params^.xsteps+k]:=werte[(j+Dateien[i].t0abs)*params^.xsteps+k]*dateien[i].faktor/sqr(dateien[i].groeszenFaktor);
+           for k:=0 to params.xsteps-1 do
+             werte[(j+Dateien[i].t0abs)*params.xsteps+k]:=werte[(j+Dateien[i].t0abs)*params.xsteps+k]*dateien[i].faktor/sqr(dateien[i].groeszenFaktor);
          if etwasGelesen then begin
            gibAus('Ich habe diese Runde schon Daten gelesen!',3);
            exit;
@@ -388,8 +384,8 @@ begin
            gSingle: begin
              blockread(f,tmps,sizeof(single));   // x
              if j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer then begin
-               params^.xstop:=tmps;
-               params^.xstart:=params^.xstop;
+               params.transformationen.xstop:=tmps;
+               params.transformationen.xstart:=params.xstop;
              end;
              for k:=0 to length(FeldgroeszenNamen)-1 do begin
                blockread(f,sa[0],sizeof(single)*length(sa));
@@ -408,8 +404,8 @@ begin
            gExtended: begin
              blockread(f,tmpe,sizeof(extended)); // x
              if j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer then begin
-               params^.xstop:=tmpe;
-               params^.xstart:=params^.xstop;
+               params.transformationen.xstop:=tmpe;
+               params.transformationen.xstart:=params.xstop;
              end;
              for k:=0 to length(FeldgroeszenNamen)-1 do begin
                blockread(f,ea[0],sizeof(extended)*length(ea));
@@ -446,12 +442,12 @@ end;
 procedure tLLWerte.gibMinMaxDichten(out wMi,wMa: extended; xmin,xmax,tmin,tmax: longint);
 var i,j:    longint;
 begin
-  wMi:=werte[xmin+tmin*params^.xsteps];
-  wMa:=Werte[xmin+tmin*params^.xsteps];
+  wMi:=werte[xmin+tmin*params.xsteps];
+  wMa:=Werte[xmin+tmin*params.xsteps];
   for i:=xmin to xmax do
     for j:=tmin to tmax do begin
-      wMi:=min(wMi,werte[i+j*params^.xsteps]);
-      wMa:=max(wMa,werte[i+j*params^.xsteps]);
+      wMi:=min(wMi,werte[i+j*params.xsteps]);
+      wMa:=max(wMa,werte[i+j*params.xsteps]);
     end;
 end;
 
@@ -460,14 +456,14 @@ var len: longint;
 begin
   len:=1;
   if senkrecht then begin
-    while 2*len<=params^.tsiz do
+    while 2*len<=params.tsiz do
       len:=len*2;
-    result:=fft(0,params^.xsteps-1,(params^.tsiz-len) div 2,((params^.tsiz+len) div 2) - 1,true,invers,vor,nach,fen,pvFehler);
+    result:=fft(0,params.xsteps-1,(params.tsiz-len) div 2,((params.tsiz+len) div 2) - 1,true,invers,vor,nach,fen,pvFehler);
   end
   else begin
-    while 2*len<=params^.xsteps do
+    while 2*len<=params.xsteps do
       len:=len*2;
-    result:=fft((params^.xsteps-len) div 2,((params^.xsteps+len) div 2) - 1,0,params^.tsiz-1,false,invers,vor,nach,fen,pvFehler);
+    result:=fft((params.xsteps-len) div 2,((params.xsteps+len) div 2) - 1,0,params.tsiz-1,false,invers,vor,nach,fen,pvFehler);
   end;
 end;
 
@@ -508,12 +504,12 @@ begin
     if senkrecht then begin
       for i:=xmin to xmax do  // Werte fenstern
         for j:=0 to tmax-tmin do
-          werte[i+(j+tmin)*params^.xsteps]:=werte[i+(j+tmin)*params^.xsteps]*fen.Werte[j];
+          werte[i+(j+tmin)*params.xsteps]:=werte[i+(j+tmin)*params.xsteps]*fen.Werte[j];
     end
     else begin
       for i:=0 to xmax-xmin do
         for j:=tmin to tmax do  // Werte fenstern
-          werte[i+xmin+j*params^.xsteps]:=werte[i+xmin+j*params^.xsteps]*fen.Werte[i];
+          werte[i+xmin+j*params.xsteps]:=werte[i+xmin+j*params.xsteps]*fen.Werte[i];
     end;
     fenavg:=0;
     for i:=0 to pmax-pmin do
@@ -528,12 +524,12 @@ begin
   if vor=doBetrQdr then begin
     for i:=xmin to xmax do
       for j:=tmin to tmax do
-        vorher:=vorher + werte[i+j*params^.xsteps];
+        vorher:=vorher + werte[i+j*params.xsteps];
   end
   else begin
     for i:=xmin to xmax do
       for j:=tmin to tmax do
-        vorher:=vorher + werte[i+j*params^.xsteps]*werte[i+j*params^.xsteps]
+        vorher:=vorher + werte[i+j*params.xsteps]*werte[i+j*params.xsteps]
           *faktoren[vor,
                   Byte(((not senkrecht) and (i=xmin)) or (senkrecht and (j=tmin)))
                +2*Byte(((not senkrecht) and (2*i=xmin+xmax+1)) or (senkrecht and (2*j=tmin+tmax+1)))];
@@ -566,16 +562,16 @@ begin
         end;
         if senkrecht then begin
           for j:=1 to haL-1 do begin
-            Ims[j]:=k*werte[i+(haL+j)*params^.xsteps];
-            Ims[2*haL-j]:=-k*werte[i+(haL+j)*params^.xsteps];
-            werte[i+(haL+j)*params^.xsteps]:=werte[i+(haL-j)*params^.xsteps];
+            Ims[j]:=k*werte[i+(haL+j)*params.xsteps];
+            Ims[2*haL-j]:=-k*werte[i+(haL+j)*params.xsteps];
+            werte[i+(haL+j)*params.xsteps]:=werte[i+(haL-j)*params.xsteps];
           end;
         end
         else begin
           for j:=1 to haL-1 do begin
-            Ims[j]:=k*werte[haL+j+i*params^.xsteps];
-            Ims[2*haL-j]:=-k*werte[haL+j+i*params^.xsteps];
-            werte[haL+j+i*params^.xsteps]:=werte[haL-j+i*params^.xsteps];
+            Ims[j]:=k*werte[haL+j+i*params.xsteps];
+            Ims[2*haL-j]:=-k*werte[haL+j+i*params.xsteps];
+            werte[haL+j+i*params.xsteps]:=werte[haL-j+i*params.xsteps];
           end;
         end;
         ims[0]:=0;
@@ -588,16 +584,16 @@ begin
         end;
         if senkrecht then begin
           for j:=1 to haL-1 do begin
-            Ims[j]:=k*werte[i+(2*haL-j)*params^.xsteps];
+            Ims[j]:=k*werte[i+(2*haL-j)*params.xsteps];
             Ims[2*haL-j]:=-Ims[j];
-            werte[i+(2*haL-j)*params^.xsteps]:=werte[i+(j)*params^.xsteps];
+            werte[i+(2*haL-j)*params.xsteps]:=werte[i+(j)*params.xsteps];
           end;
         end
         else begin
           for j:=1 to haL-1 do begin
-            Ims[j]:=k*werte[2*haL-j+i*params^.xsteps];
+            Ims[j]:=k*werte[2*haL-j+i*params.xsteps];
             Ims[2*haL-j]:=-Ims[j];
-            werte[2*haL-j+i*params^.xsteps]:=werte[j+i*params^.xsteps];
+            werte[2*haL-j+i*params.xsteps]:=werte[j+i*params.xsteps];
           end;
         end;
         ims[0]:=0;
@@ -614,27 +610,27 @@ begin
     if senkrecht then begin
       for j:=0 to tmax-tmin do begin
         if umsortierung[j]>j then begin
-          t1:=werte[i+(j+tmin)*params^.xsteps];
-          werte[i+(j+tmin)*params^.xsteps]:=werte[i+(umsortierung[j]+tmin)*params^.xsteps];
-          werte[i+(umsortierung[j]+tmin)*params^.xsteps]:=t1;
+          t1:=werte[i+(j+tmin)*params.xsteps];
+          werte[i+(j+tmin)*params.xsteps]:=werte[i+(umsortierung[j]+tmin)*params.xsteps];
+          werte[i+(umsortierung[j]+tmin)*params.xsteps]:=t1;
           t1:=ims[j];
           ims[j]:=ims[umsortierung[j]];
           ims[umsortierung[j]]:=t1;
         end;
-        in0:=in0 and (werte[i+(j+tmin)*params^.xsteps]=0) and (ims[j]=0);
+        in0:=in0 and (werte[i+(j+tmin)*params.xsteps]=0) and (ims[j]=0);
       end;
     end
     else begin
       for j:=0 to xmax-xmin do begin
         if umsortierung[j]>j then begin
-          t1:=werte[j+xmin+i*params^.xsteps];
-          werte[j+xmin+i*params^.xsteps]:=werte[umsortierung[j]+xmin+i*params^.xsteps];
-          werte[umsortierung[j]+xmin+i*params^.xsteps]:=t1;
+          t1:=werte[j+xmin+i*params.xsteps];
+          werte[j+xmin+i*params.xsteps]:=werte[umsortierung[j]+xmin+i*params.xsteps];
+          werte[umsortierung[j]+xmin+i*params.xsteps]:=t1;
           t1:=ims[j];
           ims[j]:=ims[umsortierung[j]];
           ims[umsortierung[j]]:=t1;
         end;
-        in0:=in0 and (werte[j+xmin+i*params^.xsteps]=0) and (ims[j]=0);
+        in0:=in0 and (werte[j+xmin+i*params.xsteps]=0) and (ims[j]=0);
       end;
     end;
     dist:=1;
@@ -647,12 +643,12 @@ begin
           for j:=0 to dist-1 do begin
             // x_links:  [absch+j]
             // x_rechts: [absch+j+dist]
-            t1:=wRe[wnum]*werte[i+(absch+j+tmin+dist)*params^.xsteps] - wIm[wnum]*ims[absch+j+dist];
-            t2:=wRe[wnum]*ims[absch+j+dist] + wIm[wnum]*werte[i+(absch+j+tmin+dist)*params^.xsteps];
+            t1:=wRe[wnum]*werte[i+(absch+j+tmin+dist)*params.xsteps] - wIm[wnum]*ims[absch+j+dist];
+            t2:=wRe[wnum]*ims[absch+j+dist] + wIm[wnum]*werte[i+(absch+j+tmin+dist)*params.xsteps];
 
-            werte[i+(absch+j+tmin+dist)*params^.xsteps]:=werte[i+(absch+j+tmin)*params^.xsteps]-t1;
+            werte[i+(absch+j+tmin+dist)*params.xsteps]:=werte[i+(absch+j+tmin)*params.xsteps]-t1;
             ims[absch+j+dist]:=ims[absch+j]-t2;
-            werte[i+(absch+j+tmin)*params^.xsteps]:=werte[i+(absch+j+tmin)*params^.xsteps]+t1;
+            werte[i+(absch+j+tmin)*params.xsteps]:=werte[i+(absch+j+tmin)*params.xsteps]+t1;
             ims[absch+j]:=ims[absch+j]+t2;
             wnum:=wnum+wstep;
           end;
@@ -670,12 +666,12 @@ begin
           for j:=0 to dist-1 do begin
             // x_links:  [absch+j]
             // x_rechts: [absch+j+dist]
-            t1:=wRe[wnum]*werte[absch+j+xmin+dist+i*params^.xsteps] - wIm[wnum]*ims[absch+j+dist];
-            t2:=wRe[wnum]*ims[absch+j+dist] + wIm[wnum]*werte[absch+j+xmin+dist+i*params^.xsteps];
+            t1:=wRe[wnum]*werte[absch+j+xmin+dist+i*params.xsteps] - wIm[wnum]*ims[absch+j+dist];
+            t2:=wRe[wnum]*ims[absch+j+dist] + wIm[wnum]*werte[absch+j+xmin+dist+i*params.xsteps];
 
-            werte[absch+j+xmin+dist+i*params^.xsteps]:=werte[absch+j+xmin+i*params^.xsteps]-t1;
+            werte[absch+j+xmin+dist+i*params.xsteps]:=werte[absch+j+xmin+i*params.xsteps]-t1;
             ims[absch+j+dist]:=ims[absch+j]-t2;
-            werte[absch+j+xmin+i*params^.xsteps]:=werte[absch+j+xmin+i*params^.xsteps]+t1;
+            werte[absch+j+xmin+i*params.xsteps]:=werte[absch+j+xmin+i*params.xsteps]+t1;
             ims[absch+j]:=ims[absch+j]+t2;
             wnum:=wnum+wstep;
           end;
@@ -689,63 +685,63 @@ begin
       case nach of   // werte[ i + {tmin..tmax}*xsteps] & ims[{0..tmax-tmin}] -> werte[ i + {0..tmax-tmin}*xsteps ]
         doResIms: begin     // Re_0 Re_1 Re_2 ... Re_n/2 Im_1 Im_2 ... Im_n/2-1
           for j:=0 to haL do     // Realteile zusammensuchen
-            werte[i+j*params^.xsteps]:=werte[i+(j+tmin)*params^.xsteps]/sqrt(tmax+1-tmin);
+            werte[i+j*params.xsteps]:=werte[i+(j+tmin)*params.xsteps]/sqrt(tmax+1-tmin);
           for j:=1 to haL - 1 do // Imaginärteile zusammensuchen
-            werte[i+(j+haL)*params^.xsteps]:=ims[j]/sqrt(tmax+1-tmin);
+            werte[i+(j+haL)*params.xsteps]:=ims[j]/sqrt(tmax+1-tmin);
         end;
         doResSmi: begin     // Re_0 Re_1 Re_2 ... Re_n/2 Im_n/2-1 Im_n/2-2 ... Im_1
           for j:=0 to haL do     // Realteile zusammensuchen
-            werte[i+j*params^.xsteps]:=werte[i+(j+tmin)*params^.xsteps]/sqrt(tmax+1-tmin);
+            werte[i+j*params.xsteps]:=werte[i+(j+tmin)*params.xsteps]/sqrt(tmax+1-tmin);
           for j:=1 to haL - 1 do // Imaginärteile zusammensuchen
-            werte[i+(2*haL-j)*params^.xsteps]:=ims[j]/sqrt(tmax+1-tmin);
+            werte[i+(2*haL-j)*params.xsteps]:=ims[j]/sqrt(tmax+1-tmin);
         end;
         doBetr:                                  // Abs(Re + i*Im) = Sqrt(Re^2 + Im^2)
           for j:=0 to tmax-tmin do
-            werte[i+j*params^.xsteps]:=sqrt((werte[i+(j+tmin)*params^.xsteps]*werte[i+(j+tmin)*params^.xsteps]+sqr(ims[j]))/(tmax+1-tmin));
+            werte[i+j*params.xsteps]:=sqrt((werte[i+(j+tmin)*params.xsteps]*werte[i+(j+tmin)*params.xsteps]+sqr(ims[j]))/(tmax+1-tmin));
         doBetrQdr:                               // Re^2 + Im^2
           for j:=0 to tmax-tmin do
-            werte[i+j*params^.xsteps]:=(werte[i+(j+tmin)*params^.xsteps]*werte[i+(j+tmin)*params^.xsteps]+sqr(ims[j]))/(tmax+1-tmin);
+            werte[i+j*params.xsteps]:=(werte[i+(j+tmin)*params.xsteps]*werte[i+(j+tmin)*params.xsteps]+sqr(ims[j]))/(tmax+1-tmin);
         doRes:                                   // Re
           for j:=0 to tmax-tmin do
-            werte[i+j*params^.xsteps]:=werte[i+(j+tmin)*params^.xsteps]/sqrt(tmax+1-tmin);
+            werte[i+j*params.xsteps]:=werte[i+(j+tmin)*params.xsteps]/sqrt(tmax+1-tmin);
         else begin
           gibAus('Flieht, ihr Narren! (diese Meldung sollte eigentlich nicht auftreten können)',3);
           exit;
         end;
       end;
       for j:=0 to tmax-tmin do
-        out0:=out0 and (werte[i+j*params^.xsteps]=0);
+        out0:=out0 and (werte[i+j*params.xsteps]=0);
     end
     else begin
       case nach of   // werte[ {xtmin..xmax}+i*xsteps] & ims[{0..xmax-xmin}] -> werte[ {0..xmax-xmin}+i*xsteps ]
         doResIms: begin     // Re_0 Re_1 Re_2 ... Re_n/2 Im_1 Im_2 ... Im_n/2-1
           for j:=0 to haL do     // Realteile zusammensuchen
-            werte[j+i*params^.xsteps]:=werte[j+xmin+i*params^.xsteps]/sqrt(xmax+1-xmin);
+            werte[j+i*params.xsteps]:=werte[j+xmin+i*params.xsteps]/sqrt(xmax+1-xmin);
           for j:=1 to haL - 1 do // Imaginärteile zusammensuchen
-            werte[j+haL+i*params^.xsteps]:=ims[j]/sqrt(xmax+1-xmin);
+            werte[j+haL+i*params.xsteps]:=ims[j]/sqrt(xmax+1-xmin);
         end;
         doResSmi: begin     // Re_0 Re_1 Re_2 ... Re_n/2 Im_n/2-1 Im_n/2-2 ... Im_1
           for j:=0 to haL do     // Realteile zusammensuchen
-            werte[j+i*params^.xsteps]:=werte[j+xmin+i*params^.xsteps]/sqrt(xmax+1-xmin);
+            werte[j+i*params.xsteps]:=werte[j+xmin+i*params.xsteps]/sqrt(xmax+1-xmin);
           for j:=1 to haL - 1 do // Imaginärteile zusammensuchen
-            werte[2*haL-j+i*params^.xsteps]:=ims[j]/sqrt(xmax+1-xmin);
+            werte[2*haL-j+i*params.xsteps]:=ims[j]/sqrt(xmax+1-xmin);
         end;
         doBetr:                                  // Abs(Re + i*Im) = Sqrt(Re^2 + Im^2)
           for j:=0 to xmax-xmin do
-            werte[j+i*params^.xsteps]:=sqrt((werte[j+xmin+i*params^.xsteps]*werte[j+xmin+i*params^.xsteps]+sqr(ims[j]))/(xmax+1-xmin));
+            werte[j+i*params.xsteps]:=sqrt((werte[j+xmin+i*params.xsteps]*werte[j+xmin+i*params.xsteps]+sqr(ims[j]))/(xmax+1-xmin));
         doBetrQdr:                               // Re^2 + Im^2
           for j:=0 to xmax-xmin do
-            werte[j+i*params^.xsteps]:=(werte[j+xmin+i*params^.xsteps]*werte[j+xmin+i*params^.xsteps]+sqr(ims[j]))/(xmax+1-xmin);
+            werte[j+i*params.xsteps]:=(werte[j+xmin+i*params.xsteps]*werte[j+xmin+i*params.xsteps]+sqr(ims[j]))/(xmax+1-xmin);
         doRes:                                   // Re
           for j:=0 to xmax-xmin do
-            werte[j+i*params^.xsteps]:=werte[j+xmin+i*params^.xsteps]/sqrt(xmax+1-xmin);
+            werte[j+i*params.xsteps]:=werte[j+xmin+i*params.xsteps]/sqrt(xmax+1-xmin);
         else begin
           gibAus('Flieht, ihr Narren! (diese Meldung sollte eigentlich nicht auftreten können)',3);
           exit;
         end;
       end;
       for j:=0 to xmax-xmin do
-        out0:=out0 and (werte[j+i*params^.xsteps]=0);
+        out0:=out0 and (werte[j+i*params.xsteps]=0);
     end;
   end;
 
@@ -762,12 +758,12 @@ begin
   if nach=doBetrQdr then begin
     for i:=xmin to xmax do
       for j:=tmin to tmax do
-        nachher:=nachher + werte[i+j*params^.xsteps];
+        nachher:=nachher + werte[i+j*params.xsteps];
   end
   else begin
     for i:=xmin to xmax do
       for j:=tmin to tmax do
-        nachher:=nachher + werte[i+j*params^.xsteps]*werte[i+j*params^.xsteps]
+        nachher:=nachher + werte[i+j*params.xsteps]*werte[i+j*params.xsteps]
           *faktoren[nach,
                   Byte(((not senkrecht) and (i=xmin)) or (senkrecht and (j=tmin)))
                +2*Byte(((not senkrecht) and (2*i=xmin+xmax+1)) or (senkrecht and (2*j=tmin+tmax+1)))];
@@ -784,20 +780,20 @@ end;
 procedure tLLWerte.schreibeWert(var f: textfile; x,y: longint);
 var xa,ta: extended;
 begin
- if params^.xstop=params^.xstart then
-   xa:=params^.xstop
+ if params.xstop=params.xstart then
+   xa:=params.xstop
  else
-   xa:=params^.xstart+x/(params^.xsteps-1)*(params^.xstop-params^.xstart);
- if params^.tstop=params^.tstart then
-   ta:=params^.tstop
+   xa:=params.xstart+x/(params.xsteps-1)*(params.xstop-params.xstart);
+ if params.tstop=params.tstart then
+   ta:=params.tstop
  else
-   ta:=params^.tstart+y/(params^.tsiz-1)*(params^.tstop-params^.tstart);
- writeln(f,floattostr(xa)+' '+floattostr(ta)+' '+floattostr(extended(werte[x+y*params^.xsteps])));
+   ta:=params.tstart+y/(params.tsiz-1)*(params.tstop-params.tstart);
+ writeln(f,floattostr(xa)+' '+floattostr(ta)+' '+floattostr(extended(werte[x+y*params.xsteps])));
 end;
 
 procedure tLLWerte.spiegle;
 begin
-  spiegle(0,params^.tsiz-1);
+  spiegle(0,params.tsiz-1);
 end;
 
 procedure tLLWerte.spiegle(tmin,tmax: longint);
@@ -805,10 +801,10 @@ var i,j:    longint;
     tmp:    wgen;
 begin
   for i:=tmin to tmax do
-    for j:=0 to params^.xsteps div 2 -1 do begin
-      tmp:=werte[j+i*params^.xsteps];
-      werte[j+i*params^.xsteps]:=werte[params^.xsteps-j-1+i*params^.xsteps];
-      werte[params^.xsteps-j-1+i*params^.xsteps]:=tmp;
+    for j:=0 to params.xsteps div 2 -1 do begin
+      tmp:=werte[j+i*params.xsteps];
+      werte[j+i*params.xsteps]:=werte[params.xsteps-j-1+i*params.xsteps];
+      werte[params.xsteps-j-1+i*params.xsteps]:=tmp;
     end;
 end;
 
@@ -819,44 +815,44 @@ begin
     doResIms,doResSmi: ;
     doBetr: begin
       werte[0]:=abs(extended(werte[0]));                                       // rein reell
-      for i:=1 to params^.xsteps div 2 -1 do begin                             // unterste Zeile ist reell in t
-        werte[i]:=sqrt(sqr(extended(werte[i]))+sqr(extended(werte[params^.xsteps-i])));
-        werte[params^.xsteps-i]:=werte[i];
+      for i:=1 to params.xsteps div 2 -1 do begin                             // unterste Zeile ist reell in t
+        werte[i]:=sqrt(sqr(extended(werte[i]))+sqr(extended(werte[params.xsteps-i])));
+        werte[params.xsteps-i]:=werte[i];
       end;
-      for i:=1 to params^.xsteps div 2 -1 do begin                             // mittlere Zeile ist reell in t
-        werte[i+(params^.tsiz div 2)*params^.xsteps]:=sqrt(sqr(extended(werte[i+(params^.tsiz div 2)*params^.xsteps]))+sqr(extended(werte[params^.xsteps-i+(params^.tsiz div 2)*params^.xsteps])));
-        werte[params^.xsteps-i+(params^.tsiz div 2)*params^.xsteps]:=werte[i+(params^.tsiz div 2)*params^.xsteps];
+      for i:=1 to params.xsteps div 2 -1 do begin                             // mittlere Zeile ist reell in t
+        werte[i+(params.tsiz div 2)*params.xsteps]:=sqrt(sqr(extended(werte[i+(params.tsiz div 2)*params.xsteps]))+sqr(extended(werte[params.xsteps-i+(params.tsiz div 2)*params.xsteps])));
+        werte[params.xsteps-i+(params.tsiz div 2)*params.xsteps]:=werte[i+(params.tsiz div 2)*params.xsteps];
       end;
-      werte[params^.xsteps div 2]:=abs(extended(werte[params^.xsteps div 2])); // rein reell
-      werte[params^.tsiz div 2]:=abs(extended(werte[params^.tsiz div 2]));     // rein reell
-      for i:=1 to params^.tsiz div 2 -1 do begin                               // linkeste Spalte ist reell in x
-        werte[i*params^.xsteps]:=sqrt(sqr(extended(werte[i*params^.xsteps]))+sqr(extended(werte[(params^.tsiz-i)*params^.xsteps])));
-        werte[(params^.tsiz-i)*params^.xsteps]:=werte[i*params^.xsteps];
+      werte[params.xsteps div 2]:=abs(extended(werte[params.xsteps div 2])); // rein reell
+      werte[params.tsiz div 2]:=abs(extended(werte[params.tsiz div 2]));     // rein reell
+      for i:=1 to params.tsiz div 2 -1 do begin                               // linkeste Spalte ist reell in x
+        werte[i*params.xsteps]:=sqrt(sqr(extended(werte[i*params.xsteps]))+sqr(extended(werte[(params.tsiz-i)*params.xsteps])));
+        werte[(params.tsiz-i)*params.xsteps]:=werte[i*params.xsteps];
       end;
-      for i:=1 to params^.tsiz div 2 -1 do begin                               // mittlere Spalte ist reell in x
-        werte[params^.xsteps div 2 + i*params^.xsteps]:=sqrt(sqr(extended(werte[params^.xsteps div 2 + i*params^.xsteps]))+sqr(extended(werte[params^.xsteps div 2 + (params^.tsiz-i)*params^.xsteps])));
-        werte[params^.xsteps div 2 + (params^.tsiz-i)*params^.xsteps]:=werte[params^.xsteps div 2 + i*params^.xsteps];
+      for i:=1 to params.tsiz div 2 -1 do begin                               // mittlere Spalte ist reell in x
+        werte[params.xsteps div 2 + i*params.xsteps]:=sqrt(sqr(extended(werte[params.xsteps div 2 + i*params.xsteps]))+sqr(extended(werte[params.xsteps div 2 + (params.tsiz-i)*params.xsteps])));
+        werte[params.xsteps div 2 + (params.tsiz-i)*params.xsteps]:=werte[params.xsteps div 2 + i*params.xsteps];
       end;
     end;
     doBetrQdr: begin
       werte[0]:=sqr(extended(werte[0]));                                       // rein reell
-      for i:=1 to params^.xsteps div 2 -1 do begin                             // unterste Zeile ist reell in t
-        werte[i]:=sqr(extended(werte[i]))+sqr(extended(werte[params^.xsteps-i]));
-        werte[params^.xsteps-i]:=werte[i];
+      for i:=1 to params.xsteps div 2 -1 do begin                             // unterste Zeile ist reell in t
+        werte[i]:=sqr(extended(werte[i]))+sqr(extended(werte[params.xsteps-i]));
+        werte[params.xsteps-i]:=werte[i];
       end;
-      for i:=1 to params^.xsteps div 2 -1 do begin                             // mittlere Zeile ist reell in t
-        werte[i+(params^.tsiz div 2)*params^.xsteps]:=sqr(extended(werte[i+(params^.tsiz div 2)*params^.xsteps]))+sqr(extended(werte[params^.xsteps-i+(params^.tsiz div 2)*params^.xsteps]));
-        werte[params^.xsteps-i+(params^.tsiz div 2)*params^.xsteps]:=werte[i+(params^.tsiz div 2)*params^.xsteps];
+      for i:=1 to params.xsteps div 2 -1 do begin                             // mittlere Zeile ist reell in t
+        werte[i+(params.tsiz div 2)*params.xsteps]:=sqr(extended(werte[i+(params.tsiz div 2)*params.xsteps]))+sqr(extended(werte[params.xsteps-i+(params.tsiz div 2)*params.xsteps]));
+        werte[params.xsteps-i+(params.tsiz div 2)*params.xsteps]:=werte[i+(params.tsiz div 2)*params.xsteps];
       end;
-      werte[params^.xsteps div 2]:=sqr(extended(werte[params^.xsteps div 2])); // rein reell
-      werte[params^.tsiz div 2]:=sqr(extended(werte[params^.tsiz div 2]));     // rein reell
-      for i:=1 to params^.tsiz div 2 -1 do begin                               // linkeste Spalte ist reell in x
-        werte[i*params^.xsteps]:=sqr(extended(werte[i*params^.xsteps]))+sqr(extended(werte[(params^.tsiz-i)*params^.xsteps]));
-        werte[(params^.tsiz-i)*params^.xsteps]:=werte[i*params^.xsteps];
+      werte[params.xsteps div 2]:=sqr(extended(werte[params.xsteps div 2])); // rein reell
+      werte[params.tsiz div 2]:=sqr(extended(werte[params.tsiz div 2]));     // rein reell
+      for i:=1 to params.tsiz div 2 -1 do begin                               // linkeste Spalte ist reell in x
+        werte[i*params.xsteps]:=sqr(extended(werte[i*params.xsteps]))+sqr(extended(werte[(params.tsiz-i)*params.xsteps]));
+        werte[(params.tsiz-i)*params.xsteps]:=werte[i*params.xsteps];
       end;
-      for i:=1 to params^.tsiz div 2 -1 do begin                               // mittlere Spalte ist reell in x
-        werte[params^.xsteps div 2 + i*params^.xsteps]:=sqr(extended(werte[params^.xsteps div 2 + i*params^.xsteps]))+sqr(extended(werte[params^.xsteps div 2 + (params^.tsiz-i)*params^.xsteps]));
-        werte[params^.xsteps div 2 + (params^.tsiz-i)*params^.xsteps]:=werte[params^.xsteps div 2 + i*params^.xsteps];
+      for i:=1 to params.tsiz div 2 -1 do begin                               // mittlere Spalte ist reell in x
+        werte[params.xsteps div 2 + i*params.xsteps]:=sqr(extended(werte[params.xsteps div 2 + i*params.xsteps]))+sqr(extended(werte[params.xsteps div 2 + (params.tsiz-i)*params.xsteps]));
+        werte[params.xsteps div 2 + (params.tsiz-i)*params.xsteps]:=werte[params.xsteps div 2 + i*params.xsteps];
       end;
     end;
   end{of case};
@@ -868,24 +864,24 @@ begin // bearbeitet nur den Hauptteil (außer erster und mittlerer Zeile/Spalte)
   case nb of
     doBetr: begin
       for i:=xmin to xmax do
-        for j:=1 to params^.tsiz div 2 -1 do begin
-          werte[i+j*params^.xsteps]:=
-            sqrt(sqr(extended(werte[i+j*params^.xsteps]-werte[params^.xsteps-i+(params^.tsiz-j)*params^.xsteps]))   // Re^2
-                +sqr(extended(werte[params^.xsteps-i+j*params^.xsteps]+werte[i+(params^.tsiz-j)*params^.xsteps]))); // Im^2
-          werte[params^.xsteps-i+j*params^.xsteps]:=werte[i+j*params^.xsteps];
-          werte[i+(params^.tsiz-j)*params^.xsteps]:=werte[i+j*params^.xsteps];
-          werte[params^.xsteps-i+(params^.tsiz-j)*params^.xsteps]:=werte[i+j*params^.xsteps];
+        for j:=1 to params.tsiz div 2 -1 do begin
+          werte[i+j*params.xsteps]:=
+            sqrt(sqr(extended(werte[i+j*params.xsteps]-werte[params.xsteps-i+(params.tsiz-j)*params.xsteps]))   // Re^2
+                +sqr(extended(werte[params.xsteps-i+j*params.xsteps]+werte[i+(params.tsiz-j)*params.xsteps]))); // Im^2
+          werte[params.xsteps-i+j*params.xsteps]:=werte[i+j*params.xsteps];
+          werte[i+(params.tsiz-j)*params.xsteps]:=werte[i+j*params.xsteps];
+          werte[params.xsteps-i+(params.tsiz-j)*params.xsteps]:=werte[i+j*params.xsteps];
         end;
     end;
     doBetrQdr: begin
      for i:=xmin to xmax do
-        for j:=1 to params^.tsiz div 2 -1 do begin
-          werte[i+j*params^.xsteps]:=
-             sqr(extended(werte[i+j*params^.xsteps]-werte[params^.xsteps-i+(params^.tsiz-j)*params^.xsteps]))  // Re^2
-            +sqr(extended(werte[params^.xsteps-i+j*params^.xsteps]+werte[i+(params^.tsiz-j)*params^.xsteps])); // Im^2
-          werte[params^.xsteps-i+j*params^.xsteps]:=werte[i+j*params^.xsteps];
-          werte[i+(params^.tsiz-j)*params^.xsteps]:=werte[i+j*params^.xsteps];
-          werte[params^.xsteps-i+(params^.tsiz-j)*params^.xsteps]:=werte[i+j*params^.xsteps];
+        for j:=1 to params.tsiz div 2 -1 do begin
+          werte[i+j*params.xsteps]:=
+             sqr(extended(werte[i+j*params.xsteps]-werte[params.xsteps-i+(params.tsiz-j)*params.xsteps]))  // Re^2
+            +sqr(extended(werte[params.xsteps-i+j*params.xsteps]+werte[i+(params.tsiz-j)*params.xsteps])); // Im^2
+          werte[params.xsteps-i+j*params.xsteps]:=werte[i+j*params.xsteps];
+          werte[i+(params.tsiz-j)*params.xsteps]:=werte[i+j*params.xsteps];
+          werte[params.xsteps-i+(params.tsiz-j)*params.xsteps]:=werte[i+j*params.xsteps];
         end;
     end;
   end{of case}
@@ -1008,14 +1004,14 @@ begin
   for i:=1 to length(s) do
     cbv:=cbv or not (s[i] in ['0'..'9','.',',','e','E']);
   if not cbv then result:=strtofloat(s)
-  else if s='np' then result:=params^.np
-  else if s='maxw' then result:=params^.maxW
-  else if s='minw' then result:=params^.minW
-  else if s='beta' then result:=params^.beta
-  else if s='xstart' then result:=params^.xstart
-  else if s='xstop' then result:=params^.xstop
-  else if s='tstart' then result:=params^.tstart
-  else if s='tstop' then result:=params^.tstop
+  else if s='np' then result:=params.np
+  else if s='maxw' then result:=params.maxW
+  else if s='minw' then result:=params.minW
+  else if s='beta' then result:=params.beta
+  else if s='xstart' then result:=params.xstart
+  else if s='xstop' then result:=params.xstop
+  else if s='tstart' then result:=params.tstart
+  else if s='tstop' then result:=params.tstop
   else if st then result:=1
   else if assigned(cbgv) then result:=cbgv(s)
   else result:=nan;
@@ -1039,12 +1035,12 @@ var Zeit:  extended;
 begin
   Zeit:=now;
   if gemaeszTXMinMax then begin
-    br:=params^.xsteps_;
-    ho:=params^.tsiz_;
+    br:=params.xsteps_;
+    ho:=params.tsiz_;
   end
   else begin
-    br:=params^.xsteps;
-    ho:=params^.tsiz;
+    br:=params.xsteps;
+    ho:=params.tsiz;
   end;
   gibAus('Fordere '+inttostr(floor(ho*br*sizeof(wgen)/1024/1024))+' MB RAM an ('+inttostr(br)+' x-Schritte mal '+inttostr(ho)+' t-Schritte; bisher '+inttostr(belegterSpeicher div 1024)+' MB belegt). ...',ausgaben);
   setlength(werte,br*ho);
@@ -1064,10 +1060,10 @@ begin
   b:=false;
   for j:=0 to whoehe-1 do
     for i:=0 to wbreite-1 do begin
-      xv:=min(params^.xsteps-1,max(0,ceil((i+max(0,xpmi)-1/2)/xz+xmi)));
-      xb:=min(params^.xsteps-1,max(0,ceil((i+max(0,xpmi)+1/2)/xz+xmi-1)));
-      tv:=min(params^.tsiz-1,max(0,ceil((j-1/2)/yz+tmi)));
-      tb:=min(params^.tsiz-1,max(0,ceil((j+1/2)/yz+tmi-1)));
+      xv:=min(params.xsteps-1,max(0,ceil((i+max(0,xpmi)-1/2)/xz+xmi)));
+      xb:=min(params.xsteps-1,max(0,ceil((i+max(0,xpmi)+1/2)/xz+xmi-1)));
+      tv:=min(params.tsiz-1,max(0,ceil((j-1/2)/yz+tmi)));
+      tb:=min(params.tsiz-1,max(0,ceil((j+1/2)/yz+tmi-1)));
       if xv>xb then begin
         xv:=xv-byte((i>0) or (xpmi>0));
         xb:=xb+byte((xpmi<0) or ((i=0) and (xpmi=0)));
@@ -1083,8 +1079,8 @@ begin
       pPanzahlen^[j*wbreite+i]:=(xb-xv+1)*(tb-tv+1);
       for k:=xv to xb do
         for l:=tv to tb do begin
-          b:=b or (werte[k+l*params^.xsteps]<>0);
-          pPWerte^[j*wbreite+i]:=pPWerte^[j*wbreite+i]+min(params^.maxW,max(params^.minW,werte[k+l*params^.xsteps]));
+          b:=b or (werte[k+l*params.xsteps]<>0);
+          pPWerte^[j*wbreite+i]:=pPWerte^[j*wbreite+i]+min(params.maxW,max(params.minW,werte[k+l*params.xsteps]));
         end;
     end;
   if not b then
@@ -1099,18 +1095,18 @@ begin
   setlength(result,0);
   gibAus('Schwellwerte finden ('+inttostr(xmi)+'-'+inttostr(xma)+') '+floattostr(Schw)+' ...',1);
   i:=0;
-  dx:=(params^.xstop-params^.xstart)/(params^.xsteps-1);
-  x0:=params^.xstart;
-  dy:=(params^.tstop-params^.tstart)/(params^.tsiz-1);
-  y0:=params^.tstart;
+  dx:=(params.xstop-params.xstart)/(params.xsteps-1);
+  x0:=params.xstart;
+  dy:=(params.tstop-params.tstart)/(params.tsiz-1);
+  y0:=params.tstart;
   for j:=xmi to xma do begin
     for k:=tmi to tma do begin
       vz:=0;
       for l:=0 to 1 do
         for m:=0 to 1 do
           vz:=
-             vz or (byte(werte[j-l+(k-m)*params^.xsteps]>=Schw) shl 1) or
-                    byte(werte[j-l+(k-m)*params^.xsteps]<=Schw);
+             vz or (byte(werte[j-l+(k-m)*params.xsteps]>=Schw) shl 1) or
+                    byte(werte[j-l+(k-m)*params.xsteps]<=Schw);
       if vz=3 then begin
         if i>=length(result) then
           setlength(result,length(result)+Speicherhappen);
@@ -1132,66 +1128,66 @@ var i,j:        longint;
 begin
   case richtung of
     irHorizontal: begin
-      faktor:=(qu^.params^.xstop-qu^.params^.xstart)/(qu^.params^.xsteps-1);
+      faktor:=(qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1);
       for i:=tmi to tma do begin
         int:=0;
         for j:=0 to xmi-1 do
-          int:=int+qu^.werte[j + i*qu^.params^.xsteps];
+          int:=int+qu^.werte[j + i*qu^.params.xsteps];
         for j:=xmi to xma do begin
-          int:=int+qu^.werte[j + i*qu^.params^.xsteps];
-          werte[j-xof + (i-tof)*params^.xsteps]:=int*faktor;
+          int:=int+qu^.werte[j + i*qu^.params.xsteps];
+          werte[j-xof + (i-tof)*params.xsteps]:=int*faktor;
         end;
       end;
     end;
     irEinfall: begin
       faktor:=
         sqrt(
-          sqr((qu^.params^.xstop-qu^.params^.xstart)/(qu^.params^.xsteps-1)) +
-          sqr((qu^.params^.tstop-qu^.params^.tstart)/(qu^.params^.tsiz-1)));
-      gibAus('dx = '+floattostr((qu^.params^.xstop-qu^.params^.xstart)/(qu^.params^.xsteps-1)),1);
-      gibAus('dt = '+floattostr((qu^.params^.tstop-qu^.params^.tstart)/(qu^.params^.tsiz-1)),1);
+          sqr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)) +
+          sqr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)));
+      gibAus('dx = '+floattostr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)),1);
+      gibAus('dt = '+floattostr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)),1);
       for i:=tmi to tma do begin  // von links eintretendes (inkl. Ecke links unten)
         int:=0;
         for j:=1 to min(xmi,i) do
-          int:=int+qu^.werte[xmi-j + (i-j)*qu^.params^.xsteps];
+          int:=int+qu^.werte[xmi-j + (i-j)*qu^.params.xsteps];
         for j:=0 to min(tma-i,xma-xmi) do begin
-          int:=int+qu^.werte[xmi+j + (i+j)*qu^.params^.xsteps];
-          werte[j+xmi-xof + (i+j-tof)*params^.xsteps]:=int*faktor;
+          int:=int+qu^.werte[xmi+j + (i+j)*qu^.params.xsteps];
+          werte[j+xmi-xof + (i+j-tof)*params.xsteps]:=int*faktor;
         end;
       end;
       for i:=xmi+1 to xma do begin  // von unten eintretendes (exkl. Ecke links unten)
         int:=0;
         for j:=1 to min(tmi,i) do
-          int:=int+qu^.werte[i-j + (tmi-j)*qu^.params^.xsteps];
+          int:=int+qu^.werte[i-j + (tmi-j)*qu^.params.xsteps];
         for j:=0 to min(tma-tmi,xma-i) do begin
-          int:=int+qu^.werte[i+j + (tmi+j)*qu^.params^.xsteps];
-          werte[i+j-xof + (tmi+j-tof)*params^.xsteps]:=int*faktor;
+          int:=int+qu^.werte[i+j + (tmi+j)*qu^.params.xsteps];
+          werte[i+j-xof + (tmi+j-tof)*params.xsteps]:=int*faktor;
         end;
       end;
     end;
     irAusfall: begin
       faktor:=
         sqrt(
-          sqr((qu^.params^.xstop-qu^.params^.xstart)/(qu^.params^.xsteps-1)) +
-          sqr((qu^.params^.tstop-qu^.params^.tstart)/(qu^.params^.tsiz-1)));
-      gibAus('dx = '+floattostr((qu^.params^.xstop-qu^.params^.xstart)/(qu^.params^.xsteps-1)),1);
-      gibAus('dt = '+floattostr((qu^.params^.tstop-qu^.params^.tstart)/(qu^.params^.tsiz-1)),1);
+          sqr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)) +
+          sqr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)));
+      gibAus('dx = '+floattostr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)),1);
+      gibAus('dt = '+floattostr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)),1);
       for i:=tmi to tma do begin  // nach links austretendes (inkl. Ecke links oben)
         int:=0;
-        for j:=1 to min(xmi,qu^.params^.tsiz-1-i) do
-          int:=int+qu^.werte[xmi-j + (i+j)*qu^.params^.xsteps];
+        for j:=1 to min(xmi,qu^.params.tsiz-1-i) do
+          int:=int+qu^.werte[xmi-j + (i+j)*qu^.params.xsteps];
         for j:=0 to min(i-tmi,xma-xmi) do begin
-          int:=int+qu^.werte[xmi+j + (i-j)*qu^.params^.xsteps];
-          werte[j+xmi-xof + (i-j-tof)*params^.xsteps]:=int*faktor;
+          int:=int+qu^.werte[xmi+j + (i-j)*qu^.params.xsteps];
+          werte[j+xmi-xof + (i-j-tof)*params.xsteps]:=int*faktor;
         end;
       end;
       for i:=xmi+1 to xma do begin  // nach oben austretendes (exkl. Ecke links oben)
         int:=0;
-        for j:=1 to min(qu^.params^.tsiz-1-tma,i) do
-          int:=int+qu^.werte[i-j + (tma+j)*qu^.params^.xsteps];
+        for j:=1 to min(qu^.params.tsiz-1-tma,i) do
+          int:=int+qu^.werte[i-j + (tma+j)*qu^.params.xsteps];
         for j:=0 to min(tma-tmi,xma-i) do begin
-          int:=int+qu^.werte[i+j + (tma-j)*qu^.params^.xsteps];
-          werte[i+j-xof + (tma-j-tof)*params^.xsteps]:=int*faktor;
+          int:=int+qu^.werte[i+j + (tma-j)*qu^.params.xsteps];
+          werte[i+j-xof + (tma-j-tof)*params.xsteps]:=int*faktor;
         end;
       end;
     end;
@@ -1204,66 +1200,66 @@ var i,j:        longint;
 begin
   case richtung of
     irHorizontal: begin
-      faktor:=(qu^.params^.xstop-qu^.params^.xstart)/(qu^.params^.xsteps-1);
+      faktor:=(qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1);
       for i:=tmi to tma do begin
         int:=0;
         for j:=0 to xmi-1 do
-          int:=int+qu^.werte[j + i*qu^.params^.xsteps];
+          int:=int+qu^.werte[j + i*qu^.params.xsteps];
         for j:=xmi to xma do begin
-          int:=int+qu^.werte[j + i*qu^.params^.xsteps];
-          werte[j-xof + (i-tof)*params^.xsteps]:=int*faktor;
+          int:=int+qu^.werte[j + i*qu^.params.xsteps];
+          werte[j-xof + (i-tof)*params.xsteps]:=int*faktor;
         end;
       end;
     end;
     irEinfall: begin
       faktor:=
         sqrt(
-          sqr((qu^.params^.xstop-qu^.params^.xstart)/(qu^.params^.xsteps-1)) +
-          sqr((qu^.params^.tstop-qu^.params^.tstart)/(qu^.params^.tsiz-1)));
-      gibAus('dx = '+floattostr((qu^.params^.xstop-qu^.params^.xstart)/(qu^.params^.xsteps-1)),1);
-      gibAus('dt = '+floattostr((qu^.params^.tstop-qu^.params^.tstart)/(qu^.params^.tsiz-1)),1);
+          sqr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)) +
+          sqr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)));
+      gibAus('dx = '+floattostr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)),1);
+      gibAus('dt = '+floattostr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)),1);
       for i:=tmi to tma do begin  // von links eintretendes (inkl. Ecke links unten)
         int:=0;
         for j:=1 to min(xmi,i) do
-          int:=int+qu^.werte[xmi-j + (i-j)*qu^.params^.xsteps];
+          int:=int+qu^.werte[xmi-j + (i-j)*qu^.params.xsteps];
         for j:=0 to min(tma-i,xma-xmi) do begin
-          int:=int+qu^.werte[xmi+j + (i+j)*qu^.params^.xsteps];
-          werte[j+xmi-xof + (i+j-tof)*params^.xsteps]:=int*faktor;
+          int:=int+qu^.werte[xmi+j + (i+j)*qu^.params.xsteps];
+          werte[j+xmi-xof + (i+j-tof)*params.xsteps]:=int*faktor;
         end;
       end;
       for i:=xmi+1 to xma do begin  // von unten eintretendes (exkl. Ecke links unten)
         int:=0;
         for j:=1 to min(tmi,i) do
-          int:=int+qu^.werte[i-j + (tmi-j)*qu^.params^.xsteps];
+          int:=int+qu^.werte[i-j + (tmi-j)*qu^.params.xsteps];
         for j:=0 to min(tma-tmi,xma-i) do begin
-          int:=int+qu^.werte[i+j + (tmi+j)*qu^.params^.xsteps];
-          werte[i+j-xof + (tmi+j-tof)*params^.xsteps]:=int*faktor;
+          int:=int+qu^.werte[i+j + (tmi+j)*qu^.params.xsteps];
+          werte[i+j-xof + (tmi+j-tof)*params.xsteps]:=int*faktor;
         end;
       end;
     end;
     irAusfall: begin
       faktor:=
         sqrt(
-          sqr((qu^.params^.xstop-qu^.params^.xstart)/(qu^.params^.xsteps-1)) +
-          sqr((qu^.params^.tstop-qu^.params^.tstart)/(qu^.params^.tsiz-1)));
-      gibAus('dx = '+floattostr((qu^.params^.xstop-qu^.params^.xstart)/(qu^.params^.xsteps-1)),1);
-      gibAus('dt = '+floattostr((qu^.params^.tstop-qu^.params^.tstart)/(qu^.params^.tsiz-1)),1);
+          sqr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)) +
+          sqr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)));
+      gibAus('dx = '+floattostr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)),1);
+      gibAus('dt = '+floattostr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)),1);
       for i:=tmi to tma do begin  // nach links austretendes (inkl. Ecke links oben)
         int:=0;
-        for j:=1 to min(xmi,qu^.params^.tsiz-1-i) do
-          int:=int+qu^.werte[xmi-j + (i+j)*qu^.params^.xsteps];
+        for j:=1 to min(xmi,qu^.params.tsiz-1-i) do
+          int:=int+qu^.werte[xmi-j + (i+j)*qu^.params.xsteps];
         for j:=0 to min(i-tmi,xma-xmi) do begin
-          int:=int+qu^.werte[xmi+j + (i-j)*qu^.params^.xsteps];
-          werte[j+xmi-xof + (i-j-tof)*params^.xsteps]:=int*faktor;
+          int:=int+qu^.werte[xmi+j + (i-j)*qu^.params.xsteps];
+          werte[j+xmi-xof + (i-j-tof)*params.xsteps]:=int*faktor;
         end;
       end;
       for i:=xmi+1 to xma do begin  // nach oben austretendes (exkl. Ecke links oben)
         int:=0;
-        for j:=1 to min(qu^.params^.tsiz-1-tma,i) do
-          int:=int+qu^.werte[i-j + (tma+j)*qu^.params^.xsteps];
+        for j:=1 to min(qu^.params.tsiz-1-tma,i) do
+          int:=int+qu^.werte[i-j + (tma+j)*qu^.params.xsteps];
         for j:=0 to min(tma-tmi,xma-i) do begin
-          int:=int+qu^.werte[i+j + (tma-j)*qu^.params^.xsteps];
-          werte[i+j-xof + (tma-j-tof)*params^.xsteps]:=int*faktor;
+          int:=int+qu^.werte[i+j + (tma-j)*qu^.params.xsteps];
+          werte[i+j-xof + (tma-j-tof)*params.xsteps]:=int*faktor;
         end;
       end;
     end;
@@ -1294,15 +1290,15 @@ var i:       longint;
     nur0:    boolean;
 begin
   result:=false;
-  werte.params^.xsteps:=2;
-  werte.params^.xstart:=0;
-  werte.params^.xstop:=1;
-  werte.params^.tstart:=0;
-  werte.params^.tstop:=1;
+  werte.params.xsteps:=2;
+  werte.params.transformationen.xstart:=0;
+  werte.params.transformationen.xstop:=1;
+  werte.params.transformationen.tstart:=0;
+  werte.params.transformationen.tstop:=1;
 
   if mitFFT then begin
-    if round(power(2,round(ln(werte.params^.tsiz)/ln(2))))<>werte.params^.tsiz then begin
-      gibAus('Waveletlänge muss eine Zweierpotenz sein bei Faltung mittels FFT, '+inttostr(werte.params^.tsiz)+' ist das nicht!',3);
+    if round(power(2,round(ln(werte.params.tsiz)/ln(2))))<>werte.params.tsiz then begin
+      gibAus('Waveletlänge muss eine Zweierpotenz sein bei Faltung mittels FFT, '+inttostr(werte.params.tsiz)+' ist das nicht!',3);
       exit;
     end;
     werte.holeRam(1);
@@ -1312,26 +1308,26 @@ begin
         for i:=0 to hlen do begin
           tmp:=sqr(cos(i*pi/2/tfwhm));
           if i>0 then begin
-            werte.werte[(werte.params^.tsiz-i)*2]:=  tmp*cos(-i*freq*2*pi);
-            werte.werte[(werte.params^.tsiz-i)*2+1]:=tmp*sin(-i*freq*2*pi);
+            werte.werte[(werte.params.tsiz-i)*2]:=  tmp*cos(-i*freq*2*pi);
+            werte.werte[(werte.params.tsiz-i)*2+1]:=tmp*sin(-i*freq*2*pi);
           end;
           werte.werte[2*i]:=  tmp*cos(i*freq*2*pi);
           werte.werte[2*i+1]:=tmp*sin(i*freq*2*pi);
         end;
-        for i:=hlen+1 to werte.params^.tsiz-1-hlen do begin
+        for i:=hlen+1 to werte.params.tsiz-1-hlen do begin
           werte.werte[2*i]:=0;
           werte.werte[2*i+1]:=0;
         end;
         fenster.aktiv:=false;
     //    fenster.Breite:=0;
     //    fenster.berechneWerte(werte.tsiz);
-        gibAus(inttostr(werte.params^.xsteps)+' '+inttostr(werte.params^.tsiz)+' '+inttostr(length(werte.werte)),1);
-        werte.fft(0,1,0,werte.params^.tsiz-1,true,false,doRes,doResIms,fenster,pvFehler);
+        gibAus(inttostr(werte.params.xsteps)+' '+inttostr(werte.params.tsiz)+' '+inttostr(length(werte.werte)),1);
+        werte.fft(0,1,0,werte.params.tsiz-1,true,false,doRes,doResIms,fenster,pvFehler);
       end;
       wtFrequenzfenster: begin
-        hlen:=werte.params^.tsiz div 2;
+        hlen:=werte.params.tsiz div 2;
         for i:=0 to hlen do begin
-          werte.werte[2*i]:=Byte(tfwhm*Abs(i/werte.params^.tsiz-freq)<=1); // Re=1 <=> |f-f_Mitte| < Laenge/T_fwhm
+          werte.werte[2*i]:=Byte(tfwhm*Abs(i/werte.params.tsiz-freq)<=1); // Re=1 <=> |f-f_Mitte| < Laenge/T_fwhm
           werte.werte[2*i+1]:=0; // Dummy-Wavelet
         end;
         for i:=hlen+1 to 2*hlen-1 do begin
@@ -1356,8 +1352,8 @@ begin
       exit;
     end;
     hlen:=round(tfwhm);
-    werte.params^.tsiz:=2*hlen+1;
-    setlength(werte.werte,werte.params^.xsteps*werte.params^.tsiz);
+    werte.params.tsiz:=2*hlen+1;
+    setlength(werte.werte,werte.params.xsteps*werte.params.tsiz);
     for i:=-hlen to hlen do begin
       tmp:=sqr(cos(i*pi/2/tfwhm));
       werte.werte[2*(i+hlen)]:=  tmp*cos(i*freq*2*pi);
@@ -1372,19 +1368,17 @@ begin
 end;
 
 constructor tWavelet.create;
-var ps: pTExtrainfos;
+var ps: tExtrainfos;
 begin
   inherited create;
-  getmem(ps,sizeof(tExtrainfos));
-  ps^:=tExtrainfos.create;
+  ps:=tExtrainfos.create;
   werte:=tLLWerteDouble.create(ps);
   pvFehler:=0;
 end;
 
 destructor tWavelet.destroy;
 begin
-  werte.params^.Free;
-  freemem(werte.params,sizeof(tExtrainfos));
+  werte.params.Free;
   werte.free;
   inherited destroy;
 end;