Umbenennung: gExtended -> gDouble;

Einfuegung: gExtended

3 files changed, 479 insertions, 103 deletions

diff --git a/epost.lps b/epost.lps
index 7611edb..b048fcd 100644
--- a/epost.lps
+++ b/epost.lps
@@ -7,7 +7,7 @@
       <Unit0>
         <Filename Value="epost.lpr"/>
         <IsPartOfProject Value="True"/>
-        <TopLine Value="34"/>
+        <TopLine Value="229"/>
         <CursorPos X="46" Y="50"/>
         <UsageCount Value="202"/>
         <Loaded Value="True"/>
@@ -23,8 +23,8 @@
         <Filename Value="epostunit.pas"/>
         <IsPartOfProject Value="True"/>
         <EditorIndex Value="2"/>
-        <TopLine Value="1333"/>
-        <CursorPos X="11" Y="1362"/>
+        <CursorPos Y="3"/>
+        <FoldState Value=" T3og0D5 pigjO078]9XjF0G7[95M0H411 pn4uG0;9[B4k1of0{c]Aj5lg0}54]Abo40{*11[M4Iq10{5[A4OlS0~w0[s58rM0{K5[s5W0jB]J3lZ0F2 pidjJ0c2]RCkF0BB[{x5g0E2]a2kO086]9Rl60W3]aNkM0B8 picjU0z017 piZkU054]9fjH0}^[d46p30L[942jV0K T0j'Q0{1Q"/>
         <UsageCount Value="201"/>
         <Loaded Value="True"/>
       </Unit2>
@@ -38,19 +38,19 @@
       <Unit4>
         <Filename Value="werteunit.pas"/>
         <IsPartOfProject Value="True"/>
-        <IsVisibleTab Value="True"/>
         <EditorIndex Value="3"/>
-        <TopLine Value="337"/>
-        <CursorPos X="61" Y="369"/>
-        <FoldState Value=" T3iT059 pjBja0T113T"/>
+        <TopLine Value="54"/>
+        <CursorPos X="24" Y="80"/>
+        <FoldState Value=" T3ib05B piajM0N3 pj1jW041 pmbn20A2 poLob036]RUk40R5]97k30*]RkBm30D1]+ejE071z"/>
         <UsageCount Value="200"/>
         <Loaded Value="True"/>
       </Unit4>
       <Unit5>
         <Filename Value="typenunit.pas"/>
         <IsPartOfProject Value="True"/>
+        <IsVisibleTab Value="True"/>
         <EditorIndex Value="4"/>
-        <TopLine Value="448"/>
+        <TopLine Value="403"/>
         <CursorPos X="28" Y="484"/>
         <UsageCount Value="200"/>
         <Loaded Value="True"/>
@@ -67,15 +67,15 @@
         <EditorIndex Value="1"/>
         <TopLine Value="104"/>
         <CursorPos Y="104"/>
-        <UsageCount Value="12"/>
+        <UsageCount Value="13"/>
         <Loaded Value="True"/>
       </Unit7>
       <Unit8>
         <Filename Value="../units/lowlevelunit.pas"/>
         <EditorIndex Value="6"/>
-        <TopLine Value="13"/>
-        <CursorPos X="12" Y="39"/>
-        <UsageCount Value="12"/>
+        <TopLine Value="416"/>
+        <CursorPos X="19" Y="436"/>
+        <UsageCount Value="13"/>
         <Loaded Value="True"/>
       </Unit8>
       <Unit9>
@@ -88,127 +88,130 @@
         <EditorIndex Value="5"/>
         <TopLine Value="149"/>
         <CursorPos X="32" Y="312"/>
-        <UsageCount Value="11"/>
+        <UsageCount Value="12"/>
         <Loaded Value="True"/>
       </Unit10>
     </Units>
     <JumpHistory Count="30" HistoryIndex="29">
       <Position1>
-        <Filename Value="../units/matheunit.pas"/>
-        <Caret Line="86" Column="22" TopLine="66"/>
+        <Filename Value="epostunit.pas"/>
+        <Caret Line="3285" Column="17" TopLine="3265"/>
       </Position1>
       <Position2>
-        <Filename Value="typenunit.pas"/>
-        <Caret Line="870" Column="28" TopLine="855"/>
+        <Filename Value="epostunit.pas"/>
+        <Caret Line="3286" Column="15" TopLine="3266"/>
       </Position2>
       <Position3>
-        <Filename Value="typenunit.pas"/>
-        <Caret Line="201" Column="62" TopLine="181"/>
+        <Filename Value="epostunit.pas"/>
+        <Caret Line="3394" Column="15" TopLine="3373"/>
       </Position3>
       <Position4>
-        <Filename Value="typenunit.pas"/>
-        <Caret Line="875" Column="18" TopLine="855"/>
+        <Filename Value="epostunit.pas"/>
+        <Caret Line="3421" Column="14" TopLine="3399"/>
       </Position4>
       <Position5>
-        <Filename Value="typenunit.pas"/>
-        <Caret Line="910" TopLine="882"/>
+        <Filename Value="epostunit.pas"/>
+        <Caret Line="3504" Column="47" TopLine="3505"/>
       </Position5>
       <Position6>
-        <Filename Value="../units/matheunit.pas"/>
-        <Caret Line="45" TopLine="10"/>
+        <Filename Value="epostunit.pas"/>
+        <Caret Line="3711" Column="14" TopLine="3690"/>
       </Position6>
       <Position7>
-        <Filename Value="../units/matheunit.pas"/>
-        <Caret Line="458" Column="21" TopLine="418"/>
+        <Filename Value="epostunit.pas"/>
+        <Caret Line="3822" Column="14" TopLine="3801"/>
       </Position7>
       <Position8>
-        <Filename Value="../units/matheunit.pas"/>
-        <Caret Line="94" Column="20" TopLine="65"/>
+        <Filename Value="epostunit.pas"/>
+        <Caret Line="3858" Column="28" TopLine="3838"/>
       </Position8>
       <Position9>
-        <Filename Value="epost.lpr"/>
-        <Caret Line="65" Column="68" TopLine="46"/>
+        <Filename Value="epostunit.pas"/>
+        <Caret Line="3887" Column="21" TopLine="3867"/>
       </Position9>
       <Position10>
-        <Filename Value="../units/mystringlistunit.pas"/>
-        <Caret Line="86" Column="96" TopLine="70"/>
+        <Filename Value="epostunit.pas"/>
+        <Caret Line="3917" Column="21" TopLine="3897"/>
       </Position10>
       <Position11>
-        <Filename Value="../units/mystringlistunit.pas"/>
+        <Filename Value="epostunit.pas"/>
+        <Caret Line="4054" Column="17" TopLine="4031"/>
       </Position11>
       <Position12>
-        <Filename Value="../units/mystringlistunit.pas"/>
-        <Caret Line="140" Column="47" TopLine="108"/>
+        <Filename Value="epostunit.pas"/>
+        <Caret Line="4432" Column="15" TopLine="4411"/>
       </Position12>
       <Position13>
-        <Filename Value="../units/mystringlistunit.pas"/>
-        <Caret Line="69" Column="25" TopLine="49"/>
+        <Filename Value="epostunit.pas"/>
+        <Caret Line="4482" Column="19" TopLine="4455"/>
       </Position13>
       <Position14>
-        <Filename Value="../units/mystringlistunit.pas"/>
-        <Caret Line="61" Column="61" TopLine="49"/>
+        <Filename Value="epostunit.pas"/>
+        <Caret Line="4487" Column="44" TopLine="4458"/>
       </Position14>
       <Position15>
-        <Filename Value="../units/mystringlistunit.pas"/>
+        <Filename Value="epostunit.pas"/>
+        <Caret Line="4475" Column="30" TopLine="4455"/>
       </Position15>
       <Position16>
-        <Filename Value="../units/mystringlistunit.pas"/>
-        <Caret Line="101" Column="10" TopLine="68"/>
+        <Filename Value="epostunit.pas"/>
+        <Caret Line="4484" Column="15" TopLine="4465"/>
       </Position16>
       <Position17>
-        <Filename Value="../units/mystringlistunit.pas"/>
-        <Caret Line="143" Column="3" TopLine="71"/>
+        <Filename Value="epostunit.pas"/>
+        <Caret Line="4645" Column="14" TopLine="4622"/>
       </Position17>
       <Position18>
-        <Filename Value="../units/mystringlistunit.pas"/>
-        <Caret Line="446" TopLine="406"/>
+        <Filename Value="epostunit.pas"/>
+        <Caret Line="4729" Column="14" TopLine="4705"/>
       </Position18>
       <Position19>
-        <Filename Value="epostunit.pas"/>
-        <Caret Line="1336" Column="28" TopLine="1307"/>
+        <Filename Value="werteunit.pas"/>
+        <Caret Line="1240" Column="14" TopLine="1036"/>
       </Position19>
       <Position20>
-        <Filename Value="epostunit.pas"/>
-        <Caret Line="76" Column="43" TopLine="56"/>
+        <Filename Value="werteunit.pas"/>
+        <Caret Line="332" TopLine="313"/>
       </Position20>
       <Position21>
-        <Filename Value="epostunit.pas"/>
-        <Caret Line="693" TopLine="646"/>
+        <Filename Value="../units/lowlevelunit.pas"/>
+        <Caret Line="37" Column="44"/>
       </Position21>
       <Position22>
-        <Filename Value="epostunit.pas"/>
-        <Caret Line="873" Column="48" TopLine="855"/>
+        <Filename Value="../units/lowlevelunit.pas"/>
+        <Caret Line="436" Column="10" TopLine="416"/>
       </Position22>
       <Position23>
-        <Filename Value="typenunit.pas"/>
-        <Caret Line="33" Column="27" TopLine="13"/>
+        <Filename Value="werteunit.pas"/>
+        <Caret Line="345" Column="69" TopLine="321"/>
       </Position23>
       <Position24>
-        <Filename Value="typenunit.pas"/>
-        <Caret Line="87" Column="47" TopLine="54"/>
+        <Filename Value="werteunit.pas"/>
+        <Caret Line="413" Column="12" TopLine="393"/>
       </Position24>
       <Position25>
         <Filename Value="epostunit.pas"/>
-        <Caret Line="890" Column="20" TopLine="867"/>
+        <Caret Line="4763" Column="19" TopLine="4732"/>
       </Position25>
       <Position26>
         <Filename Value="epostunit.pas"/>
-        <Caret Line="75" Column="30" TopLine="54"/>
+        <Caret Line="384" Column="4" TopLine="365"/>
       </Position26>
       <Position27>
-        <Filename Value="werteunit.pas"/>
-        <Caret Line="351" Column="134" TopLine="333"/>
+        <Filename Value="epostunit.pas"/>
+        <Caret Line="4763" Column="17" TopLine="4731"/>
       </Position27>
       <Position28>
         <Filename Value="epostunit.pas"/>
-        <Caret Line="911" TopLine="911"/>
+        <Caret Line="978" Column="29" TopLine="965"/>
       </Position28>
       <Position29>
         <Filename Value="epostunit.pas"/>
+        <Caret Line="4691" Column="32" TopLine="4653"/>
       </Position29>
       <Position30>
-        <Filename Value="epostunit.pas"/>
-        <Caret Line="1364" Column="4" TopLine="1334"/>
+        <Filename Value="werteunit.pas"/>
+        <Caret Line="514" Column="45" TopLine="496"/>
       </Position30>
     </JumpHistory>
   </ProjectSession>
diff --git a/epostunit.pas b/epostunit.pas
index 0e064d1..cac1513 100644
--- a/epostunit.pas
+++ b/epostunit.pas
@@ -106,7 +106,8 @@ type
     function disk2kontFak(dir: char; x: longint): extended;
     procedure schreibeWertIntegriert(var f: textfile; i: longint; hor: boolean);
   public
-    eWerte:                                      tLLWerteDouble;
+    eWerte:                                      tLLWerteExtended;
+    dWerte:                                      tLLWerteDouble;
     sWerte:                                      tLLWerteSingle;
     Genauigkeit:                                 tGenauigkeit;
     bezeichner:                                  string;
@@ -348,7 +349,8 @@ begin
  Genauigkeit:=gSingle;
  leseThread:=nil;
  sWerte:=tLLWerteSingle.create(ps);
- eWerte:=tLLWerteDouble.create(ps);
+ dWerte:=tLLWerteDouble.create(ps);
+ eWerte:=tLLWerteExtended.create(ps);
  Konturen:=Kont;
  wertes:=wert;
  bezeichner:='';
@@ -357,7 +359,8 @@ end;
 constructor tWerte.create(original: tWerte; xmin,xmax: longint);
 var ps:  tExtrainfos;
     pSi: pTLLWerteSingle;
-    pEx: pTLLWerteDouble;
+    pDo: pTLLWerteDouble;
+    pEx: pTLLWerteExtended;
 begin
  inherited create;
  original.warteAufBeendigungDesLeseThreads;
@@ -369,12 +372,20 @@ begin
    gSingle: begin
      pSi:=@(original.sWerte);
      sWerte:=tLLWerteSingle.create(pSi,ps,xmin,xmax);
-     eWerte:=tLLWerteDouble.create(ps);
+     dWerte:=tLLWerteDouble.create(ps);
+     eWerte:=tLLWerteExtended.create(ps);
+   end;
+   gDouble: begin
+     pDo:=@(original.dWerte);
+     sWerte:=tLLWerteSingle.create(ps);
+     dWerte:=tLLWerteDouble.create(pDo,ps,xmin,xmax);
+     eWerte:=tLLWerteExtended.create(ps);
    end;
    gExtended: begin
      sWerte:=tLLWerteSingle.create(ps);
+     dWerte:=tLLWerteDouble.create(ps);
      pEx:=@(original.eWerte);
-     eWerte:=tLLWerteDouble.create(pEx,ps,xmin,xmax);
+     eWerte:=tLLWerteExtended.create(pEx,ps,xmin,xmax);
    end;
  end{of case};
  if original.bezeichner='' then bezeichner:=''
@@ -392,6 +403,7 @@ begin
  end;
  sWerte.params.free;
  eWerte.free;
+ dWerte.free;
  sWerte.free;
  inherited destroy;
 end;
@@ -415,7 +427,8 @@ end;
 
 procedure tWerte.kopiereVon(st: boolean; original: tWerte; xmin,xmax: longint); overload;
 var pSi: pTLLWerteSingle;
-    pEx: pTLLWerteDouble;
+    pDo: pTLLWerteDouble;
+    pEx: pTLLWerteExtended;
 begin
  original.warteAufBeendigungDesLeseThreads;
  Transformationen.kopiereVon(original.Transformationen);
@@ -425,6 +438,10 @@ begin
      pSi:=@(original.sWerte);
      sWerte.kopiereVon(st,pSi,xmin,xmax);
    end;
+   gDouble: begin
+     pDo:=@(original.dWerte);
+     dWerte.kopiereVon(st,pDo,xmin,xmax);
+   end;
    gExtended: begin
      pEx:=@(original.eWerte);
      eWerte.kopiereVon(st,pEx,xmin,xmax);
@@ -438,6 +455,7 @@ function tWerte.rXsteps: longint;
 begin
   case genauigkeit of
     gSingle:   result:=sWerte.params.xsteps;
+    gDouble:   result:=dWerte.params.xsteps;
     gExtended: result:=eWerte.params.xsteps;
   end{of case};
 end;
@@ -446,6 +464,8 @@ procedure tWerte.wXsteps(xs: longint);
 begin
   sWerte.params.xsteps:=xs;
   sWerte.params.refreshKnownValues;
+  dWerte.params.xsteps:=xs;
+  dWerte.params.refreshKnownValues;
   eWerte.params.xsteps:=xs;
   eWerte.params.refreshKnownValues;
 end;
@@ -454,6 +474,7 @@ function tWerte.rTsiz: longint;
 begin
  case genauigkeit of
    gSingle:   result:=sWerte.params.tsiz;
+   gDouble:   result:=dWerte.params.tsiz;
    gExtended: result:=eWerte.params.tsiz;
  end{of case};
 end;
@@ -462,6 +483,8 @@ procedure tWerte.wTsiz(ts: longint);
 begin
   sWerte.params.tsiz:=ts;
   sWerte.params.refreshKnownValues;
+  dWerte.params.tsiz:=ts;
+  dWerte.params.refreshKnownValues;
   eWerte.params.tsiz:=ts;
   eWerte.params.refreshKnownValues;
 end;
@@ -470,6 +493,7 @@ function tWerte.rXstart: extended;
 begin
  case genauigkeit of
    gSingle:   result:=sWerte.params.xstart;
+   gDouble:   result:=dWerte.params.xstart;
    gExtended: result:=eWerte.params.xstart;
  end{of case};
 end;
@@ -481,6 +505,10 @@ begin
      sWerte.params.transformationen.xstart:=xs;
      sWerte.params.refreshKnownValues;
    end;
+   gDouble: begin
+     dWerte.params.transformationen.xstart:=xs;
+     dWerte.params.refreshKnownValues;
+   end;
    gExtended: begin
      eWerte.params.transformationen.xstart:=xs;
      eWerte.params.refreshKnownValues;
@@ -492,6 +520,7 @@ function tWerte.rXstop: extended;
 begin
  case genauigkeit of
    gSingle:   result:=sWerte.params.xstop;
+   gDouble:   result:=dWerte.params.xstop;
    gExtended: result:=eWerte.params.xstop;
  end{of case};
 end;
@@ -503,6 +532,10 @@ begin
      sWerte.params.transformationen.xstop:=xs;
      sWerte.params.refreshKnownValues;
    end;
+   gDouble: begin
+     dWerte.params.transformationen.xstop:=xs;
+     dWerte.params.refreshKnownValues;
+   end;
    gExtended: begin
      eWerte.params.transformationen.xstop:=xs;
      eWerte.params.refreshKnownValues;
@@ -514,6 +547,7 @@ function tWerte.rTstart: extended;
 begin
  case genauigkeit of
    gSingle:   result:=sWerte.params.tstart;
+   gDouble:   result:=dWerte.params.tstart;
    gExtended: result:=eWerte.params.tstart;
  end{of case};
 end;
@@ -525,6 +559,10 @@ begin
      sWerte.params.transformationen.tstart:=ts;
      sWerte.params.refreshKnownValues;
    end;
+   gDouble: begin
+     dWerte.params.transformationen.tstart:=ts;
+     dWerte.params.refreshKnownValues;
+   end;
    gExtended: begin
      eWerte.params.transformationen.tstart:=ts;
      eWerte.params.refreshKnownValues;
@@ -536,6 +574,7 @@ function tWerte.rTstop: extended;
 begin
  case genauigkeit of
    gSingle:   result:=sWerte.params.tstop;
+   gDouble:   result:=dWerte.params.tstop;
    gExtended: result:=eWerte.params.tstop;
  end{of case};
 end;
@@ -547,6 +586,10 @@ begin
      sWerte.params.transformationen.tstop:=ts;
      sWerte.params.refreshKnownValues;
    end;
+   gDouble: begin
+     dWerte.params.transformationen.tstop:=ts;
+     dWerte.params.refreshKnownValues;
+   end;
    gExtended: begin
      eWerte.params.transformationen.tstop:=ts;
      eWerte.params.refreshKnownValues;
@@ -558,6 +601,7 @@ function tWerte.rNp: extended;
 begin
  case genauigkeit of
    gSingle:   result:=sWerte.params.np;
+   gDouble:   result:=dWerte.params.np;
    gExtended: result:=eWerte.params.np;
  end{of case};
 end;
@@ -569,6 +613,10 @@ begin
      sWerte.params.np:=np;
      sWerte.params.refreshKnownValues;
    end;
+   gDouble: begin
+     dWerte.params.np:=np;
+     dWerte.params.refreshKnownValues;
+   end;
    gExtended: begin
      eWerte.params.np:=np;
      eWerte.params.refreshKnownValues;
@@ -580,6 +628,7 @@ function tWerte.rBeta: extended;
 begin
  case genauigkeit of
    gSingle:   result:=sWerte.params.beta;
+   gDouble:   result:=dWerte.params.beta;
    gExtended: result:=eWerte.params.beta;
  end{of case};
 end;
@@ -591,6 +640,10 @@ begin
      sWerte.params.beta:=beta;
      sWerte.params.refreshKnownValues;
    end;
+   gDouble: begin
+     dWerte.params.beta:=beta;
+     dWerte.params.refreshKnownValues;
+   end;
    gExtended: begin
      eWerte.params.beta:=beta;
      eWerte.params.refreshKnownValues;
@@ -602,6 +655,7 @@ function tWerte.rMinw: extended;
 begin
  case genauigkeit of
    gSingle:   result:=sWerte.params.minw;
+   gDouble:   result:=dWerte.params.minw;
    gExtended: result:=eWerte.params.minw;
  end{of case};
 end;
@@ -614,6 +668,10 @@ begin
      sWerte.params.minw:=miw;
      sWerte.params.refreshKnownValues;
    end;
+   gDouble: begin
+     dWerte.params.minw:=miw;
+     dWerte.params.refreshKnownValues;
+   end;
    gExtended: begin
      eWerte.params.minw:=miw;
      eWerte.params.refreshKnownValues;
@@ -625,6 +683,7 @@ function tWerte.rMaxw: extended;
 begin
  case genauigkeit of
    gSingle:   result:=sWerte.params.maxw;
+   gDouble:   result:=dWerte.params.maxw;
    gExtended: result:=eWerte.params.maxw;
  end{of case};
 end;
@@ -637,6 +696,10 @@ begin
      sWerte.params.maxw:=maw;
      sWerte.params.refreshKnownValues;
    end;
+   gDouble: begin
+     dWerte.params.maxw:=maw;
+     dWerte.params.refreshKnownValues;
+   end;
    gExtended: begin
      eWerte.params.maxw:=maw;
      eWerte.params.refreshKnownValues;
@@ -743,8 +806,8 @@ begin
        aufraeumen;
        exit;
      end;
-     if (Genauigkeit=gSingle) and (Vorlagen.Genauigkeit=gExtended) then
-       Genauigkeit:=gExtended;
+     if (Genauigkeit < Vorlagen.Genauigkeit) then
+       Genauigkeit:=Vorlagen.Genauigkeit;
      continue;
    end;
    if startetMit('Gamma:',s) then begin
@@ -912,6 +975,7 @@ function tWerte.ermittleInterneInputParameter(var Dateien: tGenerischeInputDatei
 // Parameter ermitteln, die aus der einzulesenden Datei hervorgehen
 var i,j,k,num,tmpi,br,SpAnz: longint;
     tmps:                    single;
+    tmpd:                    double;
     tmpe:                    extended;
     f:                       file;
     Positionen:              tLongintArray;
@@ -932,6 +996,7 @@ begin
  tmpi:=0;
  num:=0;
  tmps:=0;
+ tmpd:=0;
  SpAnz:=-1;
  setlength(Positionen,length(dateien));
  for i:=0 to length(Positionen)-1 do
@@ -1076,6 +1141,10 @@ begin
            blockread(f,tmps,sizeof(single));
            tmpe:=tmps;
          end;
+         gDouble: begin
+           blockread(f,tmpd,sizeof(double));
+           tmpe:=tmpd;
+         end;
          gExtended: blockread(f,tmpe,sizeof(extended));
        end{of case};
        tmpe:=tmpe*dateien[i].groeszenFaktor;
@@ -1090,6 +1159,10 @@ begin
            blockread(f,tmps,sizeof(single));
            tmpe:=tmps;
          end;
+         gDouble: begin
+           blockread(f,tmpd,sizeof(single));
+           tmpe:=tmpd;
+         end;
          gExtended: blockread(f,tmpe,sizeof(extended));
        end{of case};
        tmpe:=tmpe*dateien[i].groeszenFaktor;
@@ -1311,6 +1384,8 @@ begin
  case Genauigkeit of
    gSingle:
      sWerte.schreibeWertIntegriert(f,i,hor);
+   gDouble:
+     dWerte.schreibeWertIntegriert(f,i,hor);
    gExtended:
      eWerte.schreibeWertIntegriert(f,i,hor);
  end{of case};
@@ -1345,6 +1420,8 @@ begin
    case Genauigkeit of
      gSingle:
        sWerte.holeRam(3);
+     gDouble:
+       dWerte.holeRam(3);
      gExtended:
        eWerte.holeRam(3);
    end{of case};
@@ -1356,6 +1433,8 @@ begin
      case Genauigkeit of
        gSingle:
          result:=sWerte.liesDateien(inputs);
+       gDouble:
+         result:=dWerte.liesDateien(inputs);
        gExtended:
          result:=eWerte.liesDateien(inputs);
      end{of case};
@@ -1721,7 +1800,8 @@ var i,xmin,xmax,tmin,tmax: longint;
     korrelThreads:         array of tKorrelThread;
     Zeit,pvFehler:         extended;
     pSi:                   pTLLWerteSingle;
-    pEx:                   pTLLWerteDouble;
+    pDo:                   pTLLWerteDouble;
+    pEx:                   pTLLWerteExtended;
 begin
   result:=false;
   warteaufBeendigungDesLeseThreads;
@@ -1841,6 +1921,10 @@ begin
         pSi:=@(quelle.sWerte);
         eWerte.kopiereVon(st,pSi,xmin,xmax,tmin,tmax);
       end;
+      gDouble: begin
+        pDo:=@(quelle.dWerte);
+        dWerte.kopiereVon(st,pDo,xmin,xmax,tmin,tmax);
+      end;
       gExtended: begin
         pEx:=@(quelle.eWerte);
         eWerte.kopiereVon(st,pEx,xmin,xmax,tmin,tmax);
@@ -2132,6 +2216,12 @@ begin
             eWerte.werte[i + (j+tOf)*_xsteps]:=
               quelle.sWerte.werte[i*Schritt+j+tmin];
           end;
+      gDouble:
+        for i:=0 to _xsteps-1 do
+          for j:=0 to Fenster.Breite-1 do  begin
+            eWerte.werte[i + (j+tOf)*_xsteps]:=
+              quelle.dWerte.werte[i*Schritt+j+tmin];
+          end;
       gExtended:
         for i:=0 to _xsteps-1 do
           for j:=0 to Fenster.Breite-1 do
@@ -2583,6 +2673,7 @@ begin
   gibAus('Wertenachbearbeiten ...',3);
   case genauigkeit of
     gSingle:   sWerte.fft2dNachbearbeitungA(NB);
+    gDouble:   dWerte.fft2dNachbearbeitungA(NB);
     gExtended: eWerte.fft2dNachbearbeitungA(NB);
   end{of case};
   case NB of
@@ -2989,6 +3080,14 @@ begin
            delete(s,length(s),1);
            writeln(outf,s);
          end;
+       gDouble:
+         for i:=max(0,tmin) to min(_tsiz-1,tmax) do begin
+           s:='';
+           for j:=max(0,xmin) to min(_xsteps-1,xmax) do
+             s:=s+floattostr(dWerte.werte[i*_xsteps+j])+separator;
+           delete(s,length(s),1);
+           writeln(outf,s);
+         end;
        gExtended:
          for i:=max(0,tmin) to min(_tsiz-1,tmax) do begin
            s:='';
@@ -3003,6 +3102,9 @@ begin
        gSingle:
          for i:=max(0,xmin) to min(_xsteps-1,xmax) do
            writeln(outf,floattostr(disk2kont('x',i))+separator+floattostr(sWerte.werte[i]));
+       gDouble:
+         for i:=max(0,xmin) to min(_xsteps-1,xmax) do
+           writeln(outf,floattostr(disk2kont('x',i))+separator+floattostr(dWerte.werte[i]));
        gExtended:
          for i:=max(0,xmin) to min(_xsteps-1,xmax) do
            writeln(outf,floattostr(disk2kont('x',i))+separator+floattostr(eWerte.werte[i]));
@@ -3012,6 +3114,9 @@ begin
        gSingle:
          for i:=max(0,tmin) to min(_tsiz-1,tmax) do
            writeln(outf,floattostr(disk2kont('t',i))+separator+floattostr(sWerte.werte[i]));
+       gDouble:
+         for i:=max(0,tmin) to min(_tsiz-1,tmax) do
+           writeln(outf,floattostr(disk2kont('t',i))+separator+floattostr(dWerte.werte[i]));
        gExtended:
          for i:=max(0,tmin) to min(_tsiz-1,tmax) do
            writeln(outf,floattostr(disk2kont('t',i))+separator+floattostr(eWerte.werte[i]));
@@ -3020,6 +3125,8 @@ begin
      case Genauigkeit of
        gSingle:
          writeln(outf,floattostr(disk2kont('x',0))+separator+floattostr(disk2kont('t',0))+separator+floattostr(sWerte.werte[0]));
+       gDouble:
+         writeln(outf,floattostr(disk2kont('x',0))+separator+floattostr(disk2kont('t',0))+separator+floattostr(dWerte.werte[0]));
        gExtended:
          writeln(outf,floattostr(disk2kont('x',0))+separator+floattostr(disk2kont('t',0))+separator+floattostr(eWerte.werte[0]));
      end{of Case};
@@ -3163,6 +3270,8 @@ begin
    case Genauigkeit of
      gSingle:
        sWerte.erzeugeBinning(senkrecht,linien,x0,dx,params);
+     gDouble:
+       dWerte.erzeugeBinning(senkrecht,linien,x0,dx,params);
      gExtended:
        eWerte.erzeugeBinning(senkrecht,linien,x0,dx,params);
    end{of case};
@@ -3174,6 +3283,7 @@ procedure tWerte.schreibeWert(var f: textfile; x,y: longint);
 begin
   case Genauigkeit of
     gSingle:   sWerte.schreibeWert(f,x,y);
+    gDouble:   dWerte.schreibeWert(f,x,y);
     gExtended: eWerte.schreibeWert(f,x,y);
   end{of Case};
 end;
@@ -3281,6 +3391,7 @@ function tWerte.exprtofloat(st: boolean; s: string): extended;
 begin
   case genauigkeit of
     gSingle:   result:=matheunit.exprtofloat(st,s,swerte.params.knownValues,@callBackGetValue);
+    gDouble:   result:=matheunit.exprtofloat(st,s,dwerte.params.knownValues,@callBackGetValue);
     gExtended: result:=matheunit.exprtofloat(st,s,ewerte.params.knownValues,@callBackGetValue);
   end;
 end;
@@ -3306,6 +3417,8 @@ begin
  case genauigkeit of
    gSingle:
      result:=sWerte.params.transformationen;
+   gDouble:
+     result:=dWerte.params.transformationen;
    gExtended:
      result:=eWerte.params.transformationen;
  end{of case};
@@ -3395,6 +3508,21 @@ begin
           out0:=out0 and (pW.eWerte.werte[i+j*pW._xsteps]=0);
         end;
       end;
+    gDouble:
+      for j:=tMi to tMa do begin
+        if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
+          gibAus('LiKo-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+        for i:=xMi to xMa do begin
+          pW.eWerte.werte[i+j*pW._xsteps]:=0;
+          for k:=0 to length(liKo^)-1 do begin
+            pW.eWerte.werte[i+j*pW._xsteps]:=
+              pW.eWerte.werte[i+j*pW._xsteps] +
+              liKo^[k].alpha*liKo^[k].werte.dWerte.werte[(xOf+i) + (tOf+j)*liKo^[k].werte._xsteps];
+            in0:=in0 and (liKo^[k].werte.dWerte.werte[(xOf+i) + (tOf+j)*liKo^[k].werte._xsteps]=0);
+          end;
+          out0:=out0 and (pW.eWerte.werte[i+j*pW._xsteps]=0);
+        end;
+      end;
     gExtended:
      for j:=tMi to tMa do begin
        if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
@@ -3580,6 +3708,7 @@ begin
  gibAus('Thread '+inttostr(nummer)+' gestartet!',1);
  case w.Genauigkeit of
    gSingle:   if not w.sWerte.zuPixelWerten(whoehe,wbreite,xpmi,xmi,tmi,xz,yz,@werte,@anzahlen) then exit;
+   gDouble:   if not w.dWerte.zuPixelWerten(whoehe,wbreite,xpmi,xmi,tmi,xz,yz,@werte,@anzahlen) then exit;
    gExtended: if not w.eWerte.zuPixelWerten(whoehe,wbreite,xpmi,xmi,tmi,xz,yz,@werte,@anzahlen) then exit;
  end{of case};
  for i:=0 to length(werte)-1 do
@@ -3690,6 +3819,7 @@ begin
  gibAus('Dichtethread gestartet!',1);
  case w.Genauigkeit of
    gSingle:    w.sWerte.gibMinMaxDichten(minDichte,maxDichte,xmin,xmax,tmin,tmax);
+   gDouble:    w.dWerte.gibMinMaxDichten(minDichte,maxDichte,xmin,xmax,tmin,tmax);
    gExtended:  w.eWerte.gibMinMaxDichten(minDichte,maxDichte,xmin,xmax,tmin,tmax);
  end{of case};
  gibAus('Dichtethread fertig!',1);
@@ -3726,6 +3856,7 @@ begin
  gibAus('FFTthread gestartet: '+inttostr(xMi)+'-'+inttostr(xMa)+' '+inttostr(tMi)+'-'+inttostr(tMa)+' ...',1);
  case pW.Genauigkeit of
    gSingle:    erfolg:=pW.sWerte.fft(xMi,xMa,tMi,tMa,sen,inv,vo,na,fen,pvFehler);
+   gDouble:    erfolg:=pW.dWerte.fft(xMi,xMa,tMi,tMa,sen,inv,vo,na,fen,pvFehler);
    gExtended:  erfolg:=pW.eWerte.fft(xMi,xMa,tMi,tMa,sen,inv,vo,na,fen,pvFehler);
  end{of case};
  gibAus('... und fertig! ',1);
@@ -3754,6 +3885,7 @@ begin
   gibAus('Spiegelthread gestartet: '+inttostr(tMin)+'-'+inttostr(tMax)+' ...',1);
   case pW.Genauigkeit of
     gSingle:    pW.sWerte.spiegle(tMin,tMax);
+    gDouble:    pW.dWerte.spiegle(tMin,tMax);
     gExtended:  pW.eWerte.spiegle(tMin,tMax);
   end{of case};
   gibAus('... und fertig!',1);
@@ -3783,6 +3915,7 @@ begin
   gibAus('FFT2d-Nachbearbeitungsthread gestartet: '+inttostr(xMin)+'-'+inttostr(xMax)+' ...',1);
   case pW.Genauigkeit of
     gSingle:    pW.sWerte.fft2dNachbearbeitungB(xMin,xMax,nb);
+    gDouble:    pW.dWerte.fft2dNachbearbeitungB(xMin,xMax,nb);
     gExtended:  pW.eWerte.fft2dNachbearbeitungB(xMin,xMax,nb);
   end{of case};
   gibAus('... und fertig!',1);
@@ -3889,36 +4022,51 @@ begin
   end
   else begin
     case qu.Genauigkeit of
-    gExtended:
-      for i:=xmi to xma do begin
-        if (xma-i) mod ((xma-xmi) div 10) = 0 then gibAus(inttostr(i)+'/'+inttostr(xmi)+'-'+inttostr(xma),1);
-        for j:=tmi to tma do begin
-          sus:=0;
-          suc:=0;
-          for k:=max(-wl.hlen,-tOf-j) to min(wl.hlen,qu._tsiz-j-tOf-1) do begin
-            suc:=suc + qu.eWerte.werte[i+xOf+(j+k+tOf)*qu._xsteps]*wl.werte.werte[(k+wl.hlen)*2];
-            sus:=sus + qu.eWerte.werte[i+xOf+(j+k+tOf)*qu._xsteps]*wl.werte.werte[(k+wl.hlen)*2+1];
+      gSingle:
+        for i:=xmi to xma do begin
+          if (xma-i) mod ((xma-xmi) div 10) = 0 then gibAus(inttostr(i)+'/'+inttostr(xmi)+'-'+inttostr(xma),1);
+          for j:=tmi to tma do begin
+            sus:=0;
+            suc:=0;
+            for k:=max(-wl.hlen,-tOf-j) to min(wl.hlen,qu._tsiz-j-tOf-1) do begin
+              suc:=suc + qu.sWerte.werte[i+xOf+(j+k+tOf)*qu._xsteps]*wl.werte.werte[(k+wl.hlen)*2];
+              sus:=sus + qu.sWerte.werte[i+xOf+(j+k+tOf)*qu._xsteps]*wl.werte.werte[(k+wl.hlen)*2+1];
+            end;
+            zi.eWerte.werte[i+j*zi._xsteps]:=(sqr(sus)+sqr(suc))/sqr(1+2*wl.hlen);
+            in0:=in0 and (qu.sWerte.werte[i+xOf+(j+tOf)*qu._xsteps]=0);
+            out0:=out0 and (zi.eWerte.werte[i+j*zi._xsteps]=0);
           end;
-          zi.eWerte.werte[i+j*zi._xsteps]:=(sqr(sus)+sqr(suc))/sqr(1+2*wl.hlen);
-          in0:=in0 and (qu.eWerte.werte[i+xOf+(j+tOf)*qu._xsteps]=0);
-          out0:=out0 and (zi.eWerte.werte[i+j*zi._xsteps]=0);
         end;
-      end;
-    gSingle:
-      for i:=xmi to xma do begin
-        if (xma-i) mod ((xma-xmi) div 10) = 0 then gibAus(inttostr(i)+'/'+inttostr(xmi)+'-'+inttostr(xma),1);
-        for j:=tmi to tma do begin
-          sus:=0;
-          suc:=0;
-          for k:=max(-wl.hlen,-tOf-j) to min(wl.hlen,qu._tsiz-j-tOf-1) do begin
-            suc:=suc + qu.sWerte.werte[i+xOf+(j+k+tOf)*qu._xsteps]*wl.werte.werte[(k+wl.hlen)*2];
-            sus:=sus + qu.sWerte.werte[i+xOf+(j+k+tOf)*qu._xsteps]*wl.werte.werte[(k+wl.hlen)*2+1];
+      gDouble:
+        for i:=xmi to xma do begin
+          if (xma-i) mod ((xma-xmi) div 10) = 0 then gibAus(inttostr(i)+'/'+inttostr(xmi)+'-'+inttostr(xma),1);
+          for j:=tmi to tma do begin
+            sus:=0;
+            suc:=0;
+            for k:=max(-wl.hlen,-tOf-j) to min(wl.hlen,qu._tsiz-j-tOf-1) do begin
+              suc:=suc + qu.dWerte.werte[i+xOf+(j+k+tOf)*qu._xsteps]*wl.werte.werte[(k+wl.hlen)*2];
+              sus:=sus + qu.dWerte.werte[i+xOf+(j+k+tOf)*qu._xsteps]*wl.werte.werte[(k+wl.hlen)*2+1];
+            end;
+            zi.eWerte.werte[i+j*zi._xsteps]:=(sqr(sus)+sqr(suc))/sqr(1+2*wl.hlen);
+            in0:=in0 and (qu.dWerte.werte[i+xOf+(j+tOf)*qu._xsteps]=0);
+            out0:=out0 and (zi.eWerte.werte[i+j*zi._xsteps]=0);
+          end;
+        end;
+      gExtended:
+        for i:=xmi to xma do begin
+          if (xma-i) mod ((xma-xmi) div 10) = 0 then gibAus(inttostr(i)+'/'+inttostr(xmi)+'-'+inttostr(xma),1);
+          for j:=tmi to tma do begin
+            sus:=0;
+            suc:=0;
+            for k:=max(-wl.hlen,-tOf-j) to min(wl.hlen,qu._tsiz-j-tOf-1) do begin
+              suc:=suc + qu.eWerte.werte[i+xOf+(j+k+tOf)*qu._xsteps]*wl.werte.werte[(k+wl.hlen)*2];
+              sus:=sus + qu.eWerte.werte[i+xOf+(j+k+tOf)*qu._xsteps]*wl.werte.werte[(k+wl.hlen)*2+1];
+            end;
+            zi.eWerte.werte[i+j*zi._xsteps]:=(sqr(sus)+sqr(suc))/sqr(1+2*wl.hlen);
+            in0:=in0 and (qu.eWerte.werte[i+xOf+(j+tOf)*qu._xsteps]=0);
+            out0:=out0 and (zi.eWerte.werte[i+j*zi._xsteps]=0);
           end;
-          zi.eWerte.werte[i+j*zi._xsteps]:=(sqr(sus)+sqr(suc))/sqr(1+2*wl.hlen);
-          in0:=in0 and (qu.sWerte.werte[i+xOf+(j+tOf)*qu._xsteps]=0);
-          out0:=out0 and (zi.eWerte.werte[i+j*zi._xsteps]=0);
         end;
-      end;
     end{of case};
   end;
   if in0 then gibAus('Nur Nullen im Input der Korrelation!',1);
@@ -4281,6 +4429,7 @@ procedure tKonturAusWertenThread.stExecute;
 begin
   case w.Genauigkeit of
     gSingle:   punkte:=w.sWerte.findeSchwellwerte(xmi,xma,tmi,tma,s);
+    gDouble:   punkte:=w.dWerte.findeSchwellwerte(xmi,xma,tmi,tma,s);
     gExtended: punkte:=w.eWerte.findeSchwellwerte(xmi,xma,tmi,tma,s);
   end{of case};
   fertig:=true;
@@ -4324,11 +4473,19 @@ begin
     gSingle:
       case qu.Genauigkeit of
         gSingle:   zi.sWerte.integriereSingle(@(qu.sWerte),xmi,xma,tmi,tma,xof,tof,rtg);
+        gDouble:   zi.sWerte.integriereDouble(@(qu.dWerte),xmi,xma,tmi,tma,xof,tof,rtg);
         gExtended: zi.sWerte.integriereExtended(@(qu.eWerte),xmi,xma,tmi,tma,xof,tof,rtg);
       end{of case};
+    gDouble:
+      case qu.Genauigkeit of
+        gSingle:   zi.dWerte.integriereSingle(@(qu.sWerte),xmi,xma,tmi,tma,xof,tof,rtg);
+        gDouble:   zi.dWerte.integriereDouble(@(qu.dWerte),xmi,xma,tmi,tma,xof,tof,rtg);
+        gExtended: zi.dWerte.integriereExtended(@(qu.eWerte),xmi,xma,tmi,tma,xof,tof,rtg);
+      end{of case};
     gExtended:
       case qu.Genauigkeit of
         gSingle:   zi.eWerte.integriereSingle(@(qu.sWerte),xmi,xma,tmi,tma,xof,tof,rtg);
+        gDouble:   zi.eWerte.integriereDouble(@(qu.dWerte),xmi,xma,tmi,tma,xof,tof,rtg);
         gExtended: zi.eWerte.integriereExtended(@(qu.eWerte),xmi,xma,tmi,tma,xof,tof,rtg);
       end{of case};
   end{of case};
@@ -4483,6 +4640,9 @@ begin
    gSingle:
      if not w.sWerte.liesDateien(inputs) then
        exit;
+   gDouble:
+     if not w.dWerte.liesDateien(inputs) then
+       exit;
    gExtended:
      if not w.eWerte.liesDateien(inputs) then
        exit;
@@ -4555,16 +4715,24 @@ end;
 
 procedure tVerzerrThread.stExecute;
 var sw: pTLLWerteSingle;
-    ew: pTLLWerteDouble;
+    dw: pTLLWerteDouble;
+    ew: pTLLWerteExtended;
 begin
  gibAus('Verzerrthread gestartet '+floattostr(qu._minW)+' '+floattostr(qu._maxW),1);
  case qu.genauigkeit of
    gSingle: begin
      sw:=@(qu.sWerte);
+     dw:=nil;
+     ew:=nil;
+   end;
+   gDouble: begin
+     sw:=nil;
+     dw:=@(qu.dWerte);
      ew:=nil;
    end;
    gExtended: begin
      sw:=nil;
+     dw:=nil;
      ew:=@(qu.eWerte);
    end;
  end{of case};
@@ -4573,13 +4741,26 @@ begin
      case qu.genauigkeit of
        gSingle:
          zi.sWerte.kopiereVerzerrt(sw,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb);
+       gDouble:
+         zi.sWerte.kopiereVerzerrt(dw,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb);
        gExtended:
          zi.sWerte.kopiereVerzerrt(ew,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb);
      end{of case};
+   gDouble:
+     case qu.genauigkeit of
+       gSingle:
+         zi.dWerte.kopiereVerzerrt(sw,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb);
+       gDouble:
+         zi.dWerte.kopiereVerzerrt(dw,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb);
+       gExtended:
+         zi.dWerte.kopiereVerzerrt(ew,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb);
+     end{of case};
    gExtended:
      case qu.genauigkeit of
        gSingle:
          zi.eWerte.kopiereVerzerrt(sw,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb);
+       gDouble:
+         zi.eWerte.kopiereVerzerrt(dw,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb);
        gExtended:
          zi.eWerte.kopiereVerzerrt(ew,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb);
      end{of case};
diff --git a/werteunit.pas b/werteunit.pas
index 5b40ff7..b210d6b 100644
--- a/werteunit.pas
+++ b/werteunit.pas
@@ -11,6 +11,7 @@ type
 // tLLWerte ********************************************************************
   pTLLWerteSingle = ^tLLWerteSingle;
   pTLLWerteDouble = ^tLLWerteDouble;
+  pTLLWerteExtended = ^tLLWerteExtended;
   generic tLLWerte<wgen> = class(tObject)
 {
     Diese Klasse stellt nur die Berechnungsroutinen und ähnliches bereit,
@@ -24,14 +25,19 @@ type
     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;
+    constructor create(original: pTLLWerteExtended; 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: pTLLWerteExtended); overload;
     procedure kopiereVon(st: boolean; original: pTLLWerteSingle; xmin,xmax: longint); overload;
     procedure kopiereVon(st: boolean; original: pTLLWerteDouble; xmin,xmax: longint); overload;
+    procedure kopiereVon(st: boolean; original: pTLLWerteExtended; xmin,xmax: longint); overload;
     procedure kopiereVon(st: boolean; original: pTLLWerteSingle; xmin,xmax,tmin,tmax: longint); overload;
     procedure kopiereVon(st: boolean; original: pTLLWerteDouble; xmin,xmax,tmin,tmax: longint); overload;
+    procedure kopiereVon(st: boolean; original: pTLLWerteExtended; xmin,xmax,tmin,tmax: longint); overload;
     procedure kopiereVerzerrt(original: pTLLWerteSingle; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformationen); overload;
     procedure kopiereVerzerrt(original: pTLLWerteDouble; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformationen); overload;
+    procedure kopiereVerzerrt(original: pTLLWerteExtended; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformationen); overload;
     destructor destroy; override;
     function liesDateien(dateien: tGenerischeInputDateiInfoArray): boolean;
     function fft(senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; const fen: tFenster; out pvFehler: extended): boolean; overload;
@@ -51,10 +57,12 @@ type
     function zuPixelWerten(whoehe,wbreite,xpmi,xmi,tmi: longint; xz,yz: extended; pPWerte: pTExtendedArray; pPAnzahlen: pTLongintArray): boolean;
     function findeSchwellwerte(xmi,xma,tmi,tma: longint; Schw: extended): tExtPointArray;
     procedure integriereSingle(qu: pTLLWerteSingle; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung);
+    procedure integriereDouble(qu: pTLLWerteDouble; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung);
     procedure integriereExtended(qu: pTLLWerteDouble; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung);
   end;
   tLLWerteSingle = specialize tLLWerte<single>;
   tLLWerteDouble = specialize tLLWerte<double>;
+  tLLWerteExtended = specialize tLLWerte<extended>;
 // andere Typen ****************************************************************
   tWavelet = class(tObject)
     freq,tfwhm,pvFehler: extended;
@@ -91,6 +99,13 @@ begin
   kopiereVon(false,original,xmin,xmax);
 end;
 
+constructor tLLWerte.create(original: pTLLWerteExtended; ps: tExtrainfos; xmin,xmax: longint);
+begin
+  inherited create;
+  params:=ps;
+  kopiereVon(false,original,xmin,xmax);
+end;
+
 procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteSingle);
 begin
   kopiereVon(st,original,0,original^.params.xsteps-1);
@@ -101,6 +116,11 @@ begin
   kopiereVon(st,original,0,original^.params.xsteps-1);
 end;
 
+procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteExtended);
+begin
+  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);
@@ -111,6 +131,11 @@ begin
   kopiereVon(st,original,xmin,xmax,0,original^.params.tsiz-1);
 end;
 
+procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteExtended; xmin,xmax: longint);
+begin
+  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
@@ -161,6 +186,31 @@ begin
  end;
 end;
 
+procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteExtended; xmin,xmax,tmin,tmax: longint);
+var i,j: longint;
+begin
+ inherited create;
+ tmax:=min(tmax,original^.params.tsiz-1);
+ tmin:=max(tmin,0);
+ params.tsiz:=tmax+1-tmin;
+ xmax:=min(xmax,original^.params.xsteps-1);
+ xmin:=max(xmin,0);
+ 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;
+ params.refreshKnownValues;
+ 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];
+ end;
+end;
+
 procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteSingle; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformationen);
 var i,j,k,l: longint;
     tmp:     extended;
@@ -223,6 +273,37 @@ begin
    end;
 end;
 
+procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteExtended; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformationen);
+var i,j,k,l: longint;
+    tmp:     extended;
+begin
+ for i:=tmin to tmax do
+   for j:=xmin to xmax do
+     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
+       if (ZPs[i]['x']+j>=xmin) and (ZPs[i]['x']+j<=xmax) and
+          (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);
+         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] +
+           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];
+     for k:=0 to nb.count-1 do
+       nb[k].transformiereWert(tmp);
+     werte[j + i*params.xsteps]:=tmp;
+   end;
+end;
+
 destructor tLLWerte.destroy;
 begin
  setlength(werte,0);
@@ -233,8 +314,10 @@ function tLLWerte.liesDateien(dateien: tGenerischeInputDateiInfoArray): boolean;
 var i,j,k,l,tmpi,etsiz,spAnz,br: longint;
     f:                           file;
     tmps:                        single;
+    tmpd:                        double;
     tmpe,Zeit:                   extended;
     sa:                          tSingleArray;
+    da:                          tDoubleArray;
     ea:                          tExtendedArray;
     ipp:                         tProcess;
     buf:                         tByteArray;
@@ -245,6 +328,7 @@ begin
  zeit:=now;
  tmpi:=0;
  tmps:=0;
+ tmpd:=0;
  etsiz:=0;
  spAnz:=-1;
  for i:=0 to length(dateien)-1 do begin
@@ -322,6 +406,10 @@ begin
              blockread(f,tmps,sizeof(single)); // xstart
              tmpe:=tmps;
            end;
+           gDouble: begin
+             blockread(f,tmpd,sizeof(double)); // xstart
+             tmpe:=tmpd;
+           end;
            gExtended:
              blockread(f,tmpe,sizeof(extended)); // xstart
          end{of Case};
@@ -337,6 +425,10 @@ begin
              blockread(f,tmps,sizeof(single)); // xstop
              tmpe:=tmps;
            end;
+           gDouble: begin
+             blockread(f,tmpd,sizeof(double)); // xstop
+             tmpe:=tmpd;
+           end;
            gExtended:
              blockread(f,tmpe,sizeof(extended)); // xstop
          end{of Case};
@@ -354,7 +446,8 @@ begin
            exit;
          end;
          if ((sizeof(wgen) = sizeof(single)) and (Dateien[i].Genauigkeit=gSingle)) or
-            ((sizeof(wgen) = sizeof(double)) and (Dateien[i].Genauigkeit=gExtended)) then
+            ((sizeof(wgen) = sizeof(double)) and (Dateien[i].Genauigkeit=gDouble)) or
+            ((sizeof(wgen) = sizeof(extended)) and (Dateien[i].Genauigkeit=gExtended)) then
            blockread(f,werte[(j+Dateien[i].t0abs)*params.xsteps],params.xsteps*sizeof(wgen))
          else begin
            setlength(sa,params.xsteps);
@@ -376,10 +469,17 @@ begin
        case Dateien[i].Genauigkeit of
          gSingle: begin
            setlength(sa,etsiz);
+           setlength(da,0);
+           setlength(ea,0);
+         end;
+         gDouble: begin
+           setlength(sa,0);
+           setlength(da,etsiz);
            setlength(ea,0);
          end;
          gExtended: begin
            setlength(sa,0);
+           setlength(da,0);
            setlength(ea,etsiz);
          end;
        end{of case};
@@ -405,6 +505,26 @@ begin
                end;
              end;
            end;
+           gDouble: begin
+             blockread(f,tmpd,sizeof(double)); // x
+             if j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer then begin
+               params.transformationen.xstop:=tmpd;
+               params.transformationen.xstart:=params.xstop;
+             end;
+             for k:=0 to length(FeldgroeszenNamen)-1 do begin
+               blockread(f,da[0],sizeof(double)*length(da));
+               if (j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer) and
+                  (k=(Dateien[i] as tTraceInputDateiInfo).Feldnummer) then begin
+                 for l:=0 to length(da)-1 do
+                   werte[l+dateien[i].t0abs]:=da[l]*sqr(dateien[i].gamma)/sqr(dateien[i].groeszenFaktor);
+                 if etwasGelesen then begin
+                   gibAus('Ich habe diese Runde schon Daten gelesen!',3);
+                   exit;
+                 end;
+                 etwasGelesen:=true;
+               end;
+             end;
+           end;
            gExtended: begin
              blockread(f,tmpe,sizeof(extended)); // x
              if j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer then begin
@@ -1119,6 +1239,78 @@ begin
   end{of case};
 end;
 
+procedure tLLWerte.integriereDouble(qu: pTLLWerteDouble; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung);
+var i,j:        longint;
+    int,faktor: extended;
+begin
+  case richtung of
+    irHorizontal: begin
+      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];
+        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;
+        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);
+      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];
+        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;
+        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];
+        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;
+        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);
+      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:=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;
+        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:=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;
+        end;
+      end;
+    end;
+  end{of case};
+end;
+
 procedure tLLWerte.integriereExtended(qu: pTLLWerteDouble; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung);
 var i,j:        longint;
     int,faktor: extended;